Merge pull request #103 from deepagent-ltd/dev

Codex/fix desktop build oom (#102)

Author: deepagent-ai

.github/workflows/desktop-build.yml

@@ -142,6 +142,14 @@ jobs:
           APPLE_TEAM_ID: ${{ secrets.APPLE_TEAM_ID }}
         run: npx electron-builder ${{ matrix.platform_flag }} --publish never --config electron-builder.config.ts
 
+      - name: Smoke test packaged macOS app
+        if: matrix.group == 'mac'
+        working-directory: packages/desktop
+        run: |
+          executable=$(find dist/mac-arm64 -maxdepth 4 -type f -path '*/Contents/MacOS/DeepAgent Code*' -perm +111 -print -quit)
+          test -n "$executable"
+          DEEPAGENT_CODE_DESKTOP_EXECUTABLE="$executable" bun run test:subagents-cold-start
+
       - name: Upload package artifacts
         uses: actions/upload-artifact@v4
         with:

bun.lock

@@ -1,4 +1,14 @@
-import { closeSync, fsyncSync, mkdirSync, openSync, renameSync, rmSync, writeSync } from "node:fs"
+import {
+  closeSync,
+  fsyncSync,
+  linkSync,
+  mkdirSync,
+  openSync,
+  renameSync,
+  rmSync,
+  writeFileSync,
+  writeSync,
+} from "node:fs"
 import { randomUUID } from "node:crypto"
 import path from "node:path"
 
@@ -69,6 +79,20 @@ export const writeFileExclusive = (file: string, content: string): void => {
   }
 }
 
+// Built-in domain-pack seeds are immutable packaged inputs and can be regenerated after a crash.
+// Keep each visible file atomic, but avoid two fsyncs per seed during first-run corpus installation.
+export const writeRecoverableFileExclusive = (file: string, content: string): void => {
+  const dir = path.dirname(file)
+  mkdirSync(dir, { recursive: true })
+  const tmp = path.join(dir, `.${path.basename(file)}.seed-${process.pid}-${randomUUID()}`)
+  try {
+    writeFileSync(tmp, content, "utf8")
+    linkSync(tmp, file)
+  } finally {
+    rmSync(tmp, { force: true })
+  }
+}
+
 // Best-effort directory fsync so a rename/create is durable. Not all platforms/filesystems permit
 // opening a directory for fsync (Windows throws EPERM/EISDIR, some FUSE mounts reject it); a failure
 // here does not compromise the file body (already fsync'd) so it is intentionally swallowed.

packages/core/src/deepagent/atomic-write.ts

@@ -1,7 +1,7 @@
 import { mkdirSync, readdirSync, readFileSync, existsSync } from "node:fs"
 import { createHash } from "node:crypto"
 import path from "node:path"
-import { writeFileAtomic, writeFileExclusive } from "./atomic-write"
+import { writeFileAtomic, writeFileExclusive, writeRecoverableFileExclusive } from "./atomic-write"
 
 // V3 Document System (docs/28): the bedrock. All persistent state is a typed-document
 // graph — small files, content-addressed, append-only with a supersede chain, bidirectional
@@ -368,6 +368,26 @@ export class DocumentStore {
     return next
   }
 
+  // Trusted built-in corpus files are recoverable from the packaged domain packs. New seeds can
+  // therefore skip per-file fsync while retaining atomic visibility; updates still use the normal
+  // append-only durable path so shipped corpus revisions preserve version history.
+  seedActive(input: CreateDocInput): Doc {
+    const cur = this.findLogical(input)
+    if (cur) {
+      const doc = this.upsert(input)
+      if (doc.status !== "active") this.setStatus(doc.id, "active")
+      return this.get(doc.id)!
+    }
+
+    const id = this.allocateId(input.type, input.domain ?? null, input.idSlug, input.description)
+    let doc = { ...this.docFromInput(id, 1, input), status: "active" as const }
+    this.assertKnowledgeConfidence(doc)
+    this.assertLinkTargets(doc.links)
+    doc = { ...doc, hash: computeHash(doc) }
+    this.persistRecoverable(doc)
+    return doc
+  }
+
   update(id: string, body: string, links?: readonly DocLink[]): Doc {
     const cur = this.get(id)
     if (!cur) throw new Error(`update: unknown doc ${id}`)
@@ -607,6 +627,20 @@ export class DocumentStore {
     }
     this.indexDoc(doc)
   }
+  private persistRecoverable(doc: Doc): void {
+    const dir = path.join(this.root, "docs", doc.type)
+    mkdirSync(dir, { recursive: true })
+    const file = path.join(dir, `${idToFile(doc.id)}@v${doc.version}.json`)
+    try {
+      writeRecoverableFileExclusive(file, JSON.stringify(doc, null, 2))
+    } catch (error) {
+      if ((error as NodeJS.ErrnoException)?.code !== "EEXIST") throw error
+      const existing = this.readVersionFile(file)
+      if (!existing || existing.hash !== doc.hash)
+        throw new DocumentConflictError(doc.id, doc.version, existing?.hash ?? "<unreadable>", doc.hash)
+    }
+    this.indexDoc(doc)
+  }
   private replace(doc: Doc): void {
     // rewrites the SAME version in place with new status/superseded_by; rehash so INV-2 holds. This
     // is an intentional overwrite (not a new version), so it uses the crash-safe atomic OVERWRITE

packages/core/src/deepagent/document-store.ts

@@ -174,6 +174,26 @@ describe("V3 DocumentStore", () => {
 // overwrites the same version atomically (temp+fsync+rename). These tests pin the CAS + durability
 // behavior that H32-1 (v4.0.4) builds on.
 describe("F30-1 DocumentStore CAS + atomic durability", () => {
+  test("recoverable built-in seeds retain active status and exclusive-create CAS", () => {
+    const h1 = new DocumentStore(root)
+    const h2 = new DocumentStore(root)
+    const input = {
+      type: "strategy" as const,
+      scope: "durable",
+      body: "trusted built-in strategy",
+      description: "built-in strategy",
+      idSlug: "built-in-strategy",
+      confidence: { evidence_strength: "strong" as const, support_count: 1 },
+      provenance: { source: "human" as const },
+    }
+    const first = h1.seedActive(input)
+    const concurrent = h2.seedActive(input)
+    expect(first.status).toBe("active")
+    expect(concurrent.hash).toBe(first.hash)
+    expect(new DocumentStore(root).get(first.id)).toEqual(first)
+    expect(readdirSync(path.join(root, "docs", "strategy"))).toEqual([`${first.id.replaceAll(":", "__")}@v1.json`])
+  })
+
   test("normal single-writer flow is unchanged (create + updates land byte-identically)", () => {
     const a = store.create(design("v1"))
     const a2 = store.update(a.id, "v2")

packages/core/src/deepagent/durable-knowledge-store.ts

@@ -62,6 +62,7 @@ const getBase = (): Configuration => ({
     "resources/*.metainfo.xml",
     "resources/deepagent-code-cli*",
   ],
+  asarUnpack: ["out/main/chunks/node.js"],
   beforePack: () => auditPackageInputs(path.dirname(fileURLToPath(import.meta.url))),
   extraResources: [
     {

packages/core/test/deepagent/document-store.test.ts

@@ -39,7 +39,7 @@ export default defineConfig(({ command }) => ({
       rollupOptions: {
         input: { index: "src/main/index.ts", sidecar: "src/main/sidecar.ts" },
       },
-      externalizeDeps: { include: ["@lydell/node-pty"] },
+      externalizeDeps: { exclude: ["@deepagent-code/core"], include: ["@lydell/node-pty"] },
     },
     plugins: [
       {

packages/desktop/electron-builder.config.ts

@@ -36,7 +36,6 @@
   },
   "main": "./out/main/index.js",
   "dependencies": {
-    "@deepagent-code/core": "workspace:*",
     "@lydell/node-pty": "catalog:",
     "@zip.js/zip.js": "2.7.62",
     "effect": "catalog:",
@@ -51,6 +50,7 @@
   "devDependencies": {
     "@actions/artifact": "4.0.0",
     "@deepagent-code/app": "workspace:*",
+    "@deepagent-code/core": "workspace:*",
     "@deepagent-code/ui": "workspace:*",
     "@jridgewell/trace-mapping": "0.3.31",
     "@playwright/test": "catalog:",

packages/desktop/electron.vite.config.ts

@@ -4,8 +4,9 @@ import { strict as assert } from "node:assert"
 import { readdir } from "node:fs/promises"
 import path from "node:path"
 
-const chunks = path.resolve("out/main/chunks")
-const sidecar = await Bun.file(path.resolve("out/main/sidecar.js")).text()
+const main = path.resolve("out/main")
+const chunks = path.join(main, "chunks")
+const sidecar = await Bun.file(path.join(main, "sidecar.js")).text()
 const server = Bun.file(path.join(chunks, "node.js"))
 const sourceMap = Bun.file(path.join(chunks, "node.js.map"))
 const files = await readdir(chunks)
@@ -18,6 +19,22 @@ assert.deepEqual(
   [],
   "Rollup must not emit a transformed copy of the server bundle",
 )
+assert.deepEqual(
+  (
+    await Promise.all(
+      [path.join(main, "index.js"), path.join(main, "sidecar.js"), ...files.map((file) => path.join(chunks, file))]
+        .filter((file) => file.endsWith(".js"))
+        .map(async (file) =>
+          new Bun.Transpiler({ loader: "js" })
+            .scanImports(await Bun.file(file).text())
+            .filter((item) => item.path.startsWith("@deepagent-code/"))
+            .map((item) => `${path.relative(main, file)} -> ${item.path}`),
+        ),
+    )
+  ).flat(),
+  [],
+  "Packaged main process must not import TypeScript workspace packages",
+)
 
 const source = await server.text()
 assert.match(source, /sourceMappingURL=node\.js\.map/, "external server bundle is not linked to its source map")