my-durable 0.0.30 → 0.0.32

package/apps/dpi-backend/src/faux.ts

@@ -67,6 +67,12 @@ export function installFaux(models: MutableModels) {
       const ref = prompt.slice(6).trim();
       return call("check_durable_job", /^\d+$/.test(ref) ? { task_id: Number(ref) } : ref ? { job: ref } : {});
     }
+    if (prompt.startsWith("write:")) {
+      // "write:<path>|<content>" — exercises the real write tool so git-panel
+      // features (session changelist, per-turn summary) are testable.
+      const [path, ...rest] = prompt.slice(6).split("|");
+      return call("write", { path: (path ?? "").trim(), content: rest.join("|") });
+    }
     if (prompt.startsWith("search:")) return call("search_history", { query: prompt.slice(7).trim() });
     if (prompt.startsWith("page:")) return call("ping_on_call_engineer", { summary: prompt.slice(5).trim() });
     if (prompt.startsWith("Release check:"))

package/apps/dpi-backend/src/git.ts

@@ -41,6 +41,19 @@ export function git(cwd: string, args: string[], timeout = GIT_TIMEOUT): Promise
   });
 }
 
+/** One GitHub CLI call — PRs, checks and comments are forge territory and gh
+ *  is the least-token-ceremony way to reach them from a device. Same no-shell
+ *  rule: argv only, plain text back. */
+export function gh(cwd: string, args: string[], timeout = GIT_TIMEOUT): Promise<string> {
+  return new Promise((ok, fail) => {
+    // gh resolves the repo from cwd (a --repo flag wants a slug, not a path).
+    execFile("gh", args, { cwd, timeout, maxBuffer: 4 * 1024 * 1024 }, (error, stdout, stderr) => {
+      if (error) fail(Error(String(stderr || stdout || error.message).trim().slice(0, 400)));
+      else ok(String(stdout));
+    });
+  });
+}
+
 const count = (s: string, re: RegExp) => (s.match(re) ?? []).length;
 
 export interface GitStatus {
@@ -230,7 +243,13 @@ export type GitOp =
   | "ignore"
   | "checkpoint"
   | "checkpoints"
-  | "rewind";
+  | "rewind"
+  | "submodule-update"
+  | "pr-create"
+  | "pr-list"
+  | "pr-merge"
+  | "pr-checks"
+  | "pr-comment";
 
 /** Plain string an arg may never contain — we build argv ourselves anyway. */
 const safeRef = (s: string) => /^[\w./@+-]+$/.test(s) && !s.includes("..");
@@ -255,6 +274,10 @@ export async function gitOp(
     name?: string;
     /** ignore: pattern lines to append to .gitignore. */
     lines?: string[];
+    /** pr: merge method + comment body + PR number. */
+    method?: "squash" | "merge";
+    body?: string;
+    n?: number;
   } = {},
 ): Promise<{
   text: string;
@@ -263,8 +286,9 @@ export async function gitOp(
   behind?: number;
   changed?: { status: string; path: string }[];
   checkpoints?: { name: string; hash: string; date: string; subject: string }[];
+  prs?: { n: number; title: string; state: string; draft: boolean; branch: string; url: string }[];
 }> {
-  const { ref, message, target, branch, files, create, staged, rebase, setUpstream, name, lines } = opts;
+  const { ref, message, target, branch, files, create, staged, rebase, setUpstream, name, lines, method, body, n } = opts;
   switch (op) {
     case "diff":
       return { text: await git(path, ["--no-pager", "diff", ...(ref && safeRef(ref) ? [ref] : [])]) };
@@ -412,6 +436,38 @@ export async function gitOp(
       const sha = (await git(path, ["rev-parse", "--verify", refname])).trim();
       return { text: (await git(path, ["reset", "--hard", sha])).trim().split("\n")[0] ?? `rewound to ${name}` };
     }
+    case "submodule-update":
+      return { text: (await git(path, ["submodule", "update", "--init", "--recursive"], GIT_SLOW_TIMEOUT)).trim() || "submodules up to date" };
+    case "pr-create": {
+      // gh pr create — title from message, head = current branch. gh owns auth.
+      const title = (message ?? "").trim();
+      if (!title) throw Error("pr-create needs a title (message)");
+      const args = ["pr", "create", "--title", title.slice(0, 200), "--body", (body ?? title).slice(0, 4000)];
+      if (ref && safeRef(ref)) args.push("--base", ref);
+      return { text: (await gh(path, args, GIT_SLOW_TIMEOUT)).trim() };
+    }
+    case "pr-list": {
+      const raw = await gh(path, ["pr", "list", "--limit", "20", "--json", "number,title,state,isDraft,headRefName,url"]);
+      const list = JSON.parse(raw || "[]") as { number: number; title: string; state: string; isDraft: boolean; headRefName: string; url: string }[];
+      return {
+        text: "",
+        prs: list.map((r) => ({ n: r.number, title: r.title, state: r.state, draft: r.isDraft, branch: r.headRefName, url: r.url })),
+      };
+    }
+    case "pr-merge": {
+      if (!n || !Number.isInteger(n)) throw Error("pr-merge needs a PR number");
+      return { text: (await gh(path, ["pr", "merge", String(n), method === "merge" ? "--merge" : "--squash"], GIT_SLOW_TIMEOUT)).trim() || `PR #${n} merged` };
+    }
+    case "pr-checks": {
+      if (!n || !Number.isInteger(n)) throw Error("pr-checks needs a PR number");
+      return { text: (await gh(path, ["pr", "checks", String(n)], GIT_SLOW_TIMEOUT)).trim() || "no checks reported" };
+    }
+    case "pr-comment": {
+      if (!n || !Number.isInteger(n)) throw Error("pr-comment needs a PR number");
+      const text = (body ?? "").trim();
+      if (!text) throw Error("pr-comment needs a body");
+      return { text: (await gh(path, ["pr", "comment", String(n), "--body", text.slice(0, 4000)])).trim() };
+    }
     case "commit": {
       const msg = (message ?? "").trim();
       if (!msg) throw Error("commit needs a message");

package/apps/dpi-backend/src/routes.ts

@@ -11,7 +11,7 @@ import type { DevicePairing } from "./pairing.js";
 type Async = (req: Request, res: Response) => Promise<unknown>;
 const route = (fn: Async) => (req: Request, res: Response, next: NextFunction) => fn(req, res).catch(next);
 import { gitOp, gitStatus, gitStatusBatch, type GitOp } from "./git.ts";
-const GIT_OPS: GitOp[] = ["diff", "log", "log-list", "fetch", "pull", "push", "switch", "branch", "commit", "stage", "unstage", "discard", "diff-file", "stash-push", "stash-pop", "compare", "merge-abort", "show-files", "ignore", "checkpoint", "checkpoints", "rewind", "worktree-list", "worktree-add", "worktree-remove"];
+const GIT_OPS: GitOp[] = ["diff", "log", "log-list", "fetch", "pull", "push", "switch", "branch", "commit", "stage", "unstage", "discard", "diff-file", "stash-push", "stash-pop", "compare", "merge-abort", "show-files", "ignore", "checkpoint", "checkpoints", "rewind", "submodule-update", "pr-create", "pr-list", "pr-merge", "pr-checks", "pr-comment", "worktree-list", "worktree-add", "worktree-remove"];
 
 interface Locals {
   row: SessionRow;
@@ -112,6 +112,13 @@ export function v1(
 
   // ---------------------------------------------------------- device
   r.get("/device", (_req, res) => res.json(store.deviceInfo()));
+  // Model health, probed live: one provider, its first catalog model, one
+  // throwaway session. Local control plane only — deliberately NOT tunnelled.
+  r.post("/device/probe-model", route(async (req, res) => {
+    const provider = String(req.body?.provider ?? "");
+    const modelId = String(req.body?.modelId ?? "");
+    res.json(await store.probeModel(provider, modelId));
+  }));
   r.get("/tree", route(async (_req, res) => res.json(await store.tree())));
   r.get("/events", (req, res, next) => {
     try {
@@ -145,6 +152,9 @@ export function v1(
       setUpstream: body.setUpstream === true,
       name: typeof body.name === "string" ? body.name : undefined,
       lines: Array.isArray(body.lines) ? body.lines.map(String).slice(0, 50) : undefined,
+      method: body.method === "merge" ? "merge" : "squash",
+      body: typeof body.body === "string" ? body.body : undefined,
+      n: Number.isInteger(body.n) ? Number(body.n) : undefined,
     });
     res.json(out);
   }));
@@ -169,6 +179,8 @@ export function v1(
   // The zcode flagship, adapted: which files has THIS session's agent touched?
   // Powers "commit session changes" in the git panel.
   r.get("/sessions/:s/git-files", route(async (_req, res) => res.json({ files: await store.sessionTouchedFiles(L(res).row) })));
+  // Per-turn breakdown of the same data (zcode taskChangeSummary shape).
+  r.get("/sessions/:s/git-turns", route(async (_req, res) => res.json({ turns: await store.sessionGitTurns(L(res).row) })));
   r.get(
     "/sessions/:s/tasks",
     route(async (req, res) => {

package/apps/dpi-backend/src/store.ts

@@ -301,7 +301,15 @@ export class Store {
   }
 
   private defaultModel() {
-    return this.options.provider === "faux" ? fauxModels[0].id : defaultModelId;
+    if (this.options.provider === "faux") return fauxModels[0].id;
+    // The curated constant can drift out of the LIVE catalog (seen: default
+    // anthropic/claude-sonnet-5.5 while the credential store held 41 other
+    // models) — never point the default outside the catalog we serve.
+    // (this.modelList, NOT deviceInfo() — that would recurse.)
+    const catalog = this.modelList;
+    return catalog.some((m) => `${m.provider}/${m.id}` === defaultModelId)
+      ? defaultModelId
+      : (catalog[0] ? `${catalog[0].provider}/${catalog[0].id}` : defaultModelId);
   }
 
   /** True when the device has no provider key: the catalog shown is the built-in
@@ -761,6 +769,88 @@ export class Store {
     return [...paths];
   }
 
+  /**
+   * Per-turn file summary (zcode taskChangeSummary): every user turn of the
+   * session, with the files its agents wrote or edited during that turn.
+   * Line stats come from the UI against the live status — here we only know
+   * WHAT was touched and how many times.
+   */
+  async sessionGitTurns(row: SessionRow): Promise<{ when: string; files: { path: string; writes: number }[] }[]> {
+    const h = await this.openAgent(row);
+    const scanned: { when: string; files: Map<string, number> }[] = [];
+    let current: { when: string; files: Map<string, number> } | null = null;
+    const fileOf = (b: { type?: string; name?: string; arguments?: Record<string, unknown> }): string[] => {
+      if (b?.type !== "toolCall" || (b.name !== "write" && b.name !== "edit")) return [];
+      const args = b.arguments ?? {};
+      const out: string[] = [];
+      for (const f of [args.file_path, args.path]) if (typeof f === "string" && f.length > 0 && f.length < 4096) out.push(f);
+      const edits = Array.isArray(args.edits) ? (args.edits as { path?: unknown }[]) : [];
+      for (const ed of edits) if (typeof ed.path === "string" && ed.path.length > 0) out.push(ed.path);
+      return out;
+    };
+    await h.commit(async (tx) => {
+      let convs = await tx.scanConversations({}, 1000);
+      const records = [...convs.items];
+      while (convs.next && records.length < 100) {
+        convs = await tx.scanConversations({}, 1000, convs.next);
+        records.push(...convs.items);
+      }
+      for (const c of records) {
+        // ascending: a turn's tool calls FOLLOW its user entry (default is
+        // descending, which attributes every call to the NEXT turn — caught
+        // by the git-session-files test).
+        let page = await tx.scanEntries({ conversationId: c.id, order: "ascending" }, 500);
+        let count = 0;
+        for (;;) {
+          for (const e of page.items as unknown as { kind?: string; model?: readonly { content?: unknown }[] }[]) {
+            if (e.kind === "pi.user") {
+              current = { when: new Date().toISOString(), files: new Map() };
+              scanned.push(current);
+              continue;
+            }
+            if (!current) continue;
+            for (const m of e.model ?? []) {
+              const blocks = Array.isArray(m.content) ? (m.content as unknown[]) : [];
+              for (const b of blocks as { type?: string; name?: string; arguments?: Record<string, unknown> }[]) {
+                for (const f of fileOf(b)) current.files.set(f, (current.files.get(f) ?? 0) + 1);
+              }
+            }
+          }
+          count += page.items.length;
+          if (!page.next || count >= 4000) break;
+          page = await tx.scanEntries({ conversationId: c.id }, 500, page.next);
+        }
+      }
+    }, ctx);
+    return scanned
+      .map((t) => ({ when: t.when, files: [...t.files.entries()].map(([path, writes]) => ({ path, writes })).slice(0, 50) }))
+      .slice(-20);
+  }
+
+  /** One provider, one model, one throwaway session — is it alive? */
+  async probeModel(provider: string, modelId: string): Promise<{ ok: boolean; detail: string }> {
+    if (!provider || !modelId) throw invalid("provider and modelId are required");
+    const created: SessionRow[] = [];
+    try {
+      const summary = await this.create({ name: `probe-${provider}`, cwd: this.startDirs[0] ?? homedir(), model: { provider, modelId } });
+      const row = { ...summary, createdAt: Number(summary.createdAt) } as unknown as SessionRow;
+      created.push(row);
+      const h = await this.openAgent(row);
+      const c = (await h.conversation(1 as ConversationId, ctx))!;
+      const submission = await this.send(c, { content: "Reply with exactly: ok", whenBusy: "followUp", requestId: `probe-${Date.now()}` });
+      const result = await this.settled(h, submission.id as number, 45_000);
+      const text = result.status === "done" ? result.answer.text.trim() : "";
+      return {
+        ok: result.status === "done" && !!text,
+        detail: result.status === "done" ? (text || "empty answer").slice(0, 120) : ((result as { reason?: string }).reason ?? "no answer").slice(0, 120),
+      };
+    } catch (e) {
+      return { ok: false, detail: String((e as Error).message).slice(0, 160) };
+    } finally {
+      for (const r of created) void this.archive(r).catch(() => {});
+    }
+  }
+
   // ------------------------------------------------------------ agents
 
   private names(sessionId: string) {