deepdebug-local-agent 1.12.0 → 1.13.0

package/src/la-protocol-v2/jobs/manager.js

@@ -41,7 +41,7 @@ export function jobErrorCodeOf(err) {
 
 /**
  * Runner interface (F3-08c plugs the packaged agent loop in here):
- *   { name: string, kinds?: string[] (default: all of fix|implement|quality), needsLlm?: boolean (default true),
+ *   { name: string, kinds?: string[] (default: all of fix|implement|quality; `chat` only when the runner lists it: contract 2.3, capability job.chat), needsLlm?: boolean (default true),
  *     start(job, ctx): Promise<{ outcome: "pr_opened"|"no_change"|"failed"|"cancelled", errorCode?, prUrl?, branch?, commitSha?, filesChangedCount?,
  *                                diffSha256?, tests?, answer? }>,
  *     cancel(jobId): void|Promise<void> }
@@ -54,7 +54,7 @@ export function jobErrorCodeOf(err) {
  */
 export function validateRunner(r) {
     return !!r && typeof r === "object" && typeof r.name === "string" && /^[a-z0-9][a-z0-9._-]{0,31}$/.test(r.name) && typeof r.start === "function" && typeof r.cancel === "function"
-        && (r.kinds === undefined || (Array.isArray(r.kinds) && r.kinds.every((k) => ["fix", "implement", "quality"].includes(k))))
+        && (r.kinds === undefined || (Array.isArray(r.kinds) && r.kinds.every((k) => ["fix", "implement", "quality", "chat"].includes(k))))
         && (r.supportsOptions === undefined || typeof r.supportsOptions === "boolean");
 }
 
@@ -206,6 +206,8 @@ export function createJobManager({ session, tenantId, resolveWorkspace, material
         stats, audit: auditor, events: ev,
         get runner() { return theRunner; },
         get activeCount() { return active.size; },
+        /** LA-3: true while a chat job with that id is queued, being prepared (workspace clone) or running: the ChatStore waits for such a job to appear instead of saying `not_found`. */
+        isActiveChat(jobId) { const rec = active.get(jobId); return !!rec && rec.kind === "chat" && !rec.finished; },
         get running() { return running; },
         get reservedBytes() { return reserved; },
         /** F3-08c: the packaged agent loop replaces the runner (jobs already running keep the one they started with only as far as their own cancel). */

package/src/la-protocol-v2/jobs/workspace-materializer.js

@@ -88,7 +88,7 @@ export function resolveMaterializeConfig(env = process.env, warn = console.warn)
 /** Validates a repoRef and builds { host, org, repo, branch, key, url } or null. The url has NO credentials and is only https. */
 export function repoTarget(repoRef) {
     if (!repoRef || typeof repoRef !== "object") return null;
-    const host = HOSTS[repoRef.provider];
+    const host = typeof repoRef.provider === "string" && Object.hasOwn(HOSTS, repoRef.provider) ? HOSTS[repoRef.provider] : null;
     const { org, repo, branch } = repoRef;
     if (!host || typeof org !== "string" || typeof repo !== "string" || typeof branch !== "string") return null;
     if (!SEG.test(org) || !SEG.test(repo) || org === "." || org === ".." || repo === "." || repo === "..") return null;
@@ -128,7 +128,7 @@ export function createWorkspaceMaterializer({ config, tenantId, wsManager, audit
     const tenant = String(tenantId).toLowerCase();
     const git = seams.runGit || runGit;
     const stats = { admitted: 0, refused: {}, cloned: 0, reused: 0, failed: {} };
-    const inflight = new Map();   // workspaceId -> Promise<{root}>
+    const inflight = new Map();   // workspaceId -> { p:Promise<{root}>, ctl, waiters }
     let chain = Promise.resolve();   // one clone/fetch at a time on this agent
     const note = (event, extra) => { try { audit?.record({ event, ...extra }); } catch { /* the audit never breaks the data path */ } };
     const refuse = (why, extra) => { stats.refused[why] = (stats.refused[why] || 0) + 1; note("workspace_refused", { why, ...extra }); return null; };
@@ -179,7 +179,7 @@ export function createWorkspaceMaterializer({ config, tenantId, wsManager, audit
             if (!tokenUsable()) fail("credential_unavailable");
             try { askpass = ensureAskpassScript(root); } catch { fail("cache_unavailable"); }
         }
-        const env2 = gitEnv(env, { askpass, tokenFile: config.tokenFile });
+        const env2 = { ...gitEnv(env, { askpass, tokenFile: config.tokenFile, host: t.host }), GIT_CEILING_DIRECTORIES: root };   // git never discovers a repository above the cache
         const extraConfig = seams.gitConfig || [];
         const remote = seams.remoteUrl ? seams.remoteUrl(t) : t.url;
         let st = null;
@@ -189,6 +189,9 @@ export function createWorkspaceMaterializer({ config, tenantId, wsManager, audit
             const sc = readWorkspaceSidecar(dir);
             if (!sc || sc.id !== workspaceId) fail("foreign_directory");
             if (!sc.tenantId || sc.tenantId.toLowerCase() !== tenant) fail("tenant_mismatch");
+            let gitSt = null;
+            try { gitSt = fs.lstatSync(path.join(dir, ".git")); } catch { gitSt = null; }
+            if (!gitSt || !gitSt.isDirectory()) fail("not_a_clone");   // a multi-repo parent or non-git workspace: never fetch/checkout/merge in whatever repo is above it
             // existing clone: fetch the branch; move only a CLEAN tree (the previous job's local work is never reset)
             const f = await git(["fetch", "--depth", String(config.depth), "--no-tags", "--", "origin", t.branch], { cwd: dir, env: env2, timeoutMs: config.gitTimeoutMs, signal, extraConfig });
             if (!f.ok) fail(f.code === "failed" ? "fetch_failed" : f.code);
@@ -202,10 +205,21 @@ export function createWorkspaceMaterializer({ config, tenantId, wsManager, audit
             const tmp = path.join(root, `.tmp-${workspaceId}-${crypto.randomBytes(4).toString("hex")}`);
             let ok = false;
             try {
-                const c = await git(["clone", "--branch", t.branch, "--single-branch", "--depth", String(config.depth), "--no-tags", "--", remote, tmp], { env: env2, cwd: root, timeoutMs: config.cloneTimeoutMs, signal, extraConfig });
+                // the size limit is enforced WHILE cloning (not only after): a watcher aborts git as soon as the partial clone passes the limit
+                const guard = new AbortController();
+                const onAbort = () => guard.abort();
+                if (signal) { if (signal.aborted) guard.abort(); else signal.addEventListener("abort", onAbort, { once: true }); }
+                let over = false;
+                const watch = setInterval(() => { if (dirBytes(tmp, config.maxBytes) > config.maxBytes) { over = true; guard.abort(); } }, 1000);
+                let c;
+                try { c = await git(["clone", "--branch", t.branch, "--single-branch", "--depth", String(config.depth), "--no-tags", "--", remote, tmp], { env: env2, cwd: root, timeoutMs: config.cloneTimeoutMs, signal: guard.signal, extraConfig }); }
+                finally { clearInterval(watch); if (signal) signal.removeEventListener("abort", onAbort); }
+                if (over) fail("too_large");
                 if (!c.ok) fail(c.code === "failed" ? "clone_failed" : c.code);
                 if (dirBytes(tmp, config.maxBytes) > config.maxBytes) fail("too_large");
                 // the remote of the clone is the credential-free URL we built; nothing else was ever written to its config
+                // a repository may ship names that wsManager.open() writes through (a symlink at `.vh-workspace.json*`): drop them before registering
+                for (const n of fs.readdirSync(tmp)) if (n.startsWith(".vh-workspace.json")) fs.rmSync(path.join(tmp, n), { recursive: true, force: true });
                 fs.renameSync(tmp, dir);
                 ok = true;
             } finally {
@@ -231,14 +245,23 @@ export function createWorkspaceMaterializer({ config, tenantId, wsManager, audit
          * One clone at a time; a second call for the same id shares the first one's promise.
          */
         ensure(workspaceId, repoRef, signal) {
-            const running = inflight.get(workspaceId);
-            if (running) return running;
-            const p = chain.then(() => { if (signal && signal.aborted) throw new MaterializeError("aborted"); return doEnsure(workspaceId, repoRef, signal); });
-            chain = p.catch(() => {});
-            inflight.set(workspaceId, p);
-            const clear = () => { if (inflight.get(workspaceId) === p) inflight.delete(workspaceId); };
-            p.then(clear, clear);
-            return p;
+            let shared = inflight.get(workspaceId);
+            if (!shared) {
+                // the clone has its OWN controller: it is aborted only when EVERY job waiting for it has been cancelled
+                const ctl = new AbortController();
+                const p = chain.then(() => { if (ctl.signal.aborted) throw new MaterializeError("aborted"); return doEnsure(workspaceId, repoRef, ctl.signal); });
+                chain = p.catch(() => {});
+                shared = { p, ctl, waiters: 0 };
+                inflight.set(workspaceId, shared);
+                const clear = () => { if (inflight.get(workspaceId) === shared) inflight.delete(workspaceId); };
+                p.then(clear, clear);
+            }
+            shared.waiters++;
+            if (signal) {
+                const left = () => { if (--shared.waiters <= 0) shared.ctl.abort(); };
+                if (signal.aborted) left(); else signal.addEventListener("abort", left, { once: true });
+            }
+            return shared.p;
         },
     };
 }

package/src/la-protocol-v2/runtime.js

@@ -13,6 +13,7 @@ import { resolveWebhookConfig } from "./webhooks/config.js";
 import { resolveLlmClientConfig } from "./llm/config.js";
 import { resolveJobsConfig } from "./jobs/config.js";
 import { loadContract } from "./contract.js";
+import { resolveChatConfig, chatRequested } from "./chat/config.js";
 
 const UUID = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/;
 const WORKSPACE_ID = /^[A-Za-z0-9_.-]{0,64}$/;
@@ -86,6 +87,10 @@ export async function buildV2Link({ tenantId, agentId, signing, wsManager, getWo
     // ./jobs/agent2 is loaded. It needs jobs, the LLM client (agent2 reaches the model ONLY through this agent: DLP + key holder) and DLP enforce; when one is
     // missing the job receiver is NOT installed (never silently another runner).
     let agent2Runner = null;
+    // LA-1/LA-3 (contract 2.3, LOCAL_AGENT_CHAT, default off): chat on the Local Agent. It rides on the agent2 runner and on the content handlers (job.stream / chat.session are
+    // served by them), so it exists only when both do; otherwise it says why and stays off (never a half-working chat: `job.chat` is announced only by a complete one).
+    let chat = null;
+    let chatReported = false;
     if (String(env.LOCAL_AGENT_RUNNER ?? "").trim().toLowerCase() === "agent2") {
         const a2 = await import("./jobs/agent2/config.js");
         const a2cfg = a2.resolveAgent2RunnerConfig(env, (m) => log.warn(m));
@@ -97,12 +102,23 @@ export async function buildV2Link({ tenantId, agentId, signing, wsManager, getWo
         else {
             const { createAgent2Runner } = await import("./jobs/agent2/runner.js");
             const { makeWorkspaceResolver } = await import("./jobs/install.js");
+            const chatCfg = resolveChatConfig(env, (m) => log.warn(m));
+            if (chatCfg.enabled) {
+                chatReported = true;
+                if (!contentCfg.enabled) err("[la-chat] ERROR: LOCAL_AGENT_CHAT=true but the content handlers are not on (LOCAL_AGENT_CONTENT_HANDLERS=true and LOCAL_AGENT_DLP_MODE=enforce): nothing could serve job.stream / chat.session. The chat stays off");
+                else {
+                    const { createChat } = await import("./chat/index.js");
+                    try { chat = createChat({ config: chatCfg, tenantId: tenant, env, log, isActive: (id) => !!(link.jobs && link.jobs.isActiveChat(id)) }); } catch { err("[la-chat] ERROR: the chat store could not be created (LOCAL_AGENT_CHAT_DIR): the chat stays off"); }
+                }
+            }
+            a2cfg.chat = !!chat;
             const resolveWs = makeWorkspaceResolver({ wsManager, getWorkspaceRoot, tenantId: tenant });
-            agent2Runner = createAgent2Runner({ config: a2cfg, tenantId: tenant, resolveWorkspaceRoot: (id) => resolveWs(id)?.root || null, getSession: () => link.session, signing, env, log });
+            agent2Runner = createAgent2Runner({ config: a2cfg, tenantId: tenant, resolveWorkspaceRoot: (id) => resolveWs(id)?.root || null, getSession: () => link.session, signing, env, log, chat });
             jobRunner = agent2Runner;
             if (jobsCfg.maxConcurrent !== 1) { log.warn("[la-agent2] agent2 runs one job at a time: LOCAL_AGENT_JOBS_MAX_CONCURRENT is forced to 1"); jobsCfg = { ...jobsCfg, maxConcurrent: 1 }; }
         }
     }
+    if (chatRequested(env) && !chat && !chatReported) err("[la-chat] ERROR: LOCAL_AGENT_CHAT=true needs LOCAL_AGENT_JOBS, LOCAL_AGENT_RUNNER=agent2 (with the LLM client and DLP enforce) and the content handlers: the chat stays off");
     if (jobsCfg.enabled) {
         const { validateRunner } = await import("./jobs/manager.js");
         const given = jobRunner && validateRunner(jobRunner) ? jobRunner : null;
@@ -138,7 +154,10 @@ export async function buildV2Link({ tenantId, agentId, signing, wsManager, getWo
             capabilities: ["protocol.v2", "v1.commands", "chunk.base64", ...contentCaps, ...incidentCaps, ...webhookCaps, ...llmCaps, ...jobCaps, ...jobOptionCaps, ...policyCaps, ...v21Caps],
             // contract 2.1 (e): `llm.key.held` is a snapshot taken at every connect (register and hello alike): announced only while the holder has a
             // valid, unexpired key (a revoked or expired one is not announced from the next connection on). `link` is assigned below, before any attach.
-            dynamicCapabilities: () => (llmCfg.enabled && link.llm && link.llm.holder.held ? ["llm.key.held"] : []),
+            // contract 2.3: `job.chat` (+ `job.inline.16k`, a prompt of 16 KiB) only from a complete chat: the store, the content handlers, the agent2 runner and an agent2 whose /health
+            // listed `chat` (probeChat below). The CP sends kind:"chat" and a long inline input only to a session that announced them.
+            dynamicCapabilities: () => [...(llmCfg.enabled && link.llm && link.llm.holder.held ? ["llm.key.held"] : []),
+                ...(chat && agent2Runner && runner === agent2Runner && agent2Runner.chatReady ? ["job.chat", "job.inline.16k"] : [])],
             getWorkspaces: () => {
                 const open = (wsManager?.list?.() || []).map((w) => ({
                     workspaceId: String(w.id || ""),
@@ -158,7 +177,12 @@ export async function buildV2Link({ tenantId, agentId, signing, wsManager, getWo
     });
     if (contentCfg.enabled) {
         const { installContentHandlers } = await import("./content-handlers/install.js");
-        installContentHandlers({ link, tenantId: tenant, wsManager, getWorkspaceRoot, config: contentCfg, env, log });
+        installContentHandlers({ link, tenantId: tenant, wsManager, getWorkspaceRoot, config: contentCfg, env, log, chat: chat ? chat.content : null });
+    }
+    if (chat) {
+        link.chat = chat;
+        const closeBase = link.close.bind(link);
+        link.close = () => { chat.close(); closeBase(); };
     }
     if (llmCfg.enabled) {
         const { installLlmKey } = await import("./llm-key/install.js");
@@ -182,6 +206,11 @@ export async function buildV2Link({ tenantId, agentId, signing, wsManager, getWo
             link.close = () => { closeJobs(); agent2Runner.close().catch(() => {}); };
         }
     }
+    if (chat && agent2Runner && runner === agent2Runner) {
+        // which kinds does agent2 run? (/health). Waits at most LOCAL_AGENT_CHAT_PROBE_MS so the first register already says `job.chat`; in spawn mode this starts agent2 now
+        const probe = agent2Runner.probeChat();
+        if (chat.config.probeWaitMs > 0) await Promise.race([probe, new Promise((r) => { const t = setTimeout(r, chat.config.probeWaitMs); if (t.unref) t.unref(); })]);
+    }
     let webhookSource = null;
     if (webhookCfg.enabled) {
         const { createWebhookSource } = await import("../incident-detector/sources/webhook-source.js");

package/src/workspace-manager.js

@@ -1,5 +1,6 @@
 import path from "path";
 import fs from "fs";
+import crypto from "crypto";
 import { exists, listRecursive, readFile, stat } from "./fs-utils.js";
 import { WORKSPACE_SIDECAR, readWorkspaceSidecar } from "./utils/open-gate.js";
 import { detectProject } from "./detectors.js";
@@ -87,13 +88,13 @@ export class WorkspaceManager {
         try {
             // Atomic (temp + rename) and owner-only: the sidecar's tenantId is
             // read by ROOT-RECOVERY, so it must never be observed half-written.
-            const tmp = `${file}.${process.pid}.tmp`;
+            const tmp = `${file}.${process.pid}.${crypto.randomBytes(6).toString("hex")}.tmp`;
             fs.writeFileSync(tmp, JSON.stringify({
                 id: state.id,
                 tenantId: state.tenantId || null,
                 root: state.root,
                 openedAt: state.openedAt
-            }, null, 2) + "\n", { mode: 0o600 });
+            }, null, 2) + "\n", { mode: 0o600, flag: "wx" });   // wx: never write through a pre-existing file/symlink
             fs.renameSync(tmp, file);
             // Single-repo clones ARE git repos and the PR path runs `git add -A`:
             // keep the sidecar out of git via .git/info/exclude (never touches