@agentconnect.md/daemon 1.0.0-rc.66 → 1.0.0-rc.68

package/dist/index.js

@@ -13322,6 +13322,50 @@ const WorkspaceReadContent = object({
 	nextOffset: number().int().nonnegative().optional(),
 	truncated: boolean().optional()
 });
+/**
+* Agent workspace git ops (C→D REQ → REP) — the console's on-demand controls for
+* a git-repo workspace. Like list/read these run daemon-local; the CP proxies the
+* outcome and stores nothing.
+*
+* These are DATA-oriented: a non-repo workspace (`isRepo:false`), a dirty tree,
+* or a pull that can't fast-forward (offline, diverged, local edits) all come
+* back as a normal REP — NOT an `error` frame. Only an unknown agent
+* (`BAD_PAYLOAD`) or an unexpected git/fs failure (`INTERNAL`) is an error.
+*/
+/** C→D REQ: report `git status` of the agent's workspace (is it clean?). */
+const WorkspaceGitStatusReq = object({ agentId: string().min(1) });
+/** One changed path in a `git status`. `index`/`workingDir` are git's per-file XY
+*  status chars (' ', 'M', 'A', 'D', 'R', 'C', 'U', '?', …). */
+const WorkspaceGitFile = object({
+	path: string(),
+	index: string(),
+	workingDir: string()
+});
+/** D→C REP (corr = the req id): the working-tree status. */
+const WorkspaceGitStatus = object({
+	agentId: string(),
+	isRepo: boolean(),
+	clean: boolean(),
+	branch: string().optional(),
+	tracking: string().optional(),
+	ahead: number().int().nonnegative().optional(),
+	behind: number().int().nonnegative().optional(),
+	files: array(WorkspaceGitFile).optional(),
+	truncated: boolean().optional()
+});
+/** C→D REQ: force a fast-forward-only `git pull` in the agent's workspace now. */
+const WorkspaceGitPullReq = object({ agentId: string().min(1) });
+/** D→C REP (corr = the req id): the pull outcome. A failed pull is DATA
+*  (`ok:false` + `detail`), not an error frame (see the section docblock). */
+const WorkspaceGitPullResult = object({
+	agentId: string(),
+	isRepo: boolean(),
+	ok: boolean(),
+	detail: string().optional(),
+	changed: number().int().nonnegative().optional(),
+	insertions: number().int().nonnegative().optional(),
+	deletions: number().int().nonnegative().optional()
+});
 //#endregion
 //#region ../protocol/dist/frames/telemetry.js
 /**
@@ -13446,6 +13490,10 @@ const FRAME_SCHEMAS = {
 	"workspace/list/page": WorkspaceListPage,
 	"workspace/read": WorkspaceReadReq,
 	"workspace/read/content": WorkspaceReadContent,
+	"workspace/gitstatus": WorkspaceGitStatusReq,
+	"workspace/gitstatus/result": WorkspaceGitStatus,
+	"workspace/gitpull": WorkspaceGitPullReq,
+	"workspace/gitpull/result": WorkspaceGitPullResult,
 	"config/push": object({ keys: record(string(), unknown()) }),
 	"daemon/restart": object({
 		reason: string(),
@@ -13545,6 +13593,10 @@ discriminatedUnion("type", [
 	frame("workspace/list/page", FRAME_SCHEMAS["workspace/list/page"]),
 	frame("workspace/read", FRAME_SCHEMAS["workspace/read"]),
 	frame("workspace/read/content", FRAME_SCHEMAS["workspace/read/content"]),
+	frame("workspace/gitstatus", FRAME_SCHEMAS["workspace/gitstatus"]),
+	frame("workspace/gitstatus/result", FRAME_SCHEMAS["workspace/gitstatus/result"]),
+	frame("workspace/gitpull", FRAME_SCHEMAS["workspace/gitpull"]),
+	frame("workspace/gitpull/result", FRAME_SCHEMAS["workspace/gitpull/result"]),
 	frame("config/push", FRAME_SCHEMAS["config/push"]),
 	frame("daemon/restart", FRAME_SCHEMAS["daemon/restart"]),
 	frame("daemon/upgrade", FRAME_SCHEMAS["daemon/upgrade"]),
@@ -13671,7 +13723,7 @@ function isFrame(type) {
 }
 //#endregion
 //#region src/workspace/workspace-manager.ts
-const PULL_TIMEOUT_MS = 4500;
+const PULL_TIMEOUT_MS$1 = 4500;
 const cloneInFlight = /* @__PURE__ */ new Map();
 async function prepareWorkspace(agent) {
 	const cwd = agent.workspace.path;
@@ -13686,7 +13738,7 @@ async function prepareWorkspace(agent) {
 		return cwd;
 	}
 	if (agent.workspace.pullOnNewSession) try {
-		await Promise.race([simpleGit(cwd).pull(["--ff-only"]), new Promise((_, rej) => setTimeout(() => rej(/* @__PURE__ */ new Error("pull timeout")), PULL_TIMEOUT_MS))]);
+		await Promise.race([simpleGit(cwd).pull(["--ff-only"]), new Promise((_, rej) => setTimeout(() => rej(/* @__PURE__ */ new Error("pull timeout")), PULL_TIMEOUT_MS$1))]);
 	} catch {}
 	return cwd;
 }
@@ -82763,6 +82815,12 @@ var CpClient = class {
 			case "workspace/read":
 				this.deps.workspaceRead.read(frame.payload).then((content) => this.reply(frame, "workspace/read/content", content)).catch((err) => this.workspaceError(frame.id, "workspace/read", err));
 				return;
+			case "workspace/gitstatus":
+				this.deps.workspaceGit.status(frame.payload.agentId).then((status) => this.reply(frame, "workspace/gitstatus/result", status)).catch((err) => this.workspaceError(frame.id, "workspace/gitstatus", err));
+				return;
+			case "workspace/gitpull":
+				this.deps.workspaceGit.pull(frame.payload.agentId).then((result) => this.reply(frame, "workspace/gitpull/result", result)).catch((err) => this.workspaceError(frame.id, "workspace/gitpull", err));
+				return;
 			case "agent/prompt":
 				this.sendError(frame.id, "INTERNAL", "agent/prompt not implemented", false);
 				return;
@@ -82860,6 +82918,104 @@ function createSessionReader(store) {
 	};
 }
 //#endregion
+//#region src/cp/workspace-git.ts
+/**
+* `WorkspaceGit` — the seam answering the CP's `workspace/gitstatus` and
+* `workspace/gitpull` REQs against an agent's local git-repo workspace. Sibling
+* to {@link WorkspaceReader}: git runs daemon-local and only the outcome is
+* proxied to the console (§1/§12), never the repo.
+*
+* DATA vs error: a from-scratch workspace (`isRepo:false`), a dirty tree, or a
+* pull that can't fast-forward (offline, diverged, would clobber local edits) are
+* all normal REPs — the caller renders them. Only an unknown agentId throws
+* ({@link WorkspaceViolationError} → `BAD_PAYLOAD`); an unexpected git/fs failure
+* on `status` propagates (→ `INTERNAL`). Git-provided text is scrubbed of the
+* absolute workspace path before it leaves the daemon (raw git errors embed host
+* paths that must not reach the CP/UI).
+*/
+/** On-demand pull is interactive, so allow more headroom than the 4.5s
+*  best-effort pull at session start (workspace-manager.ts). */
+const PULL_TIMEOUT_MS = 2e4;
+/** Cap the changed-file list so a huge working tree can't overflow the frame. */
+const MAX_STATUS_FILES = 500;
+function createWorkspaceGit(workspaceRootByAgent) {
+	function rootFor(agentId) {
+		const root = workspaceRootByAgent(agentId);
+		if (!root) throw new WorkspaceViolationError(`unknown agent "${agentId}"`);
+		return root;
+	}
+	/** A git-repo workspace has a `.git` at its root; from-scratch does not. */
+	function isRepo(root) {
+		return existsSync(join(root, ".git"));
+	}
+	/** Strip the absolute workspace path out of git-provided text so no host path
+	*  leaks to the CP/UI. Repo-relative paths in the message are kept. */
+	function scrub(root, msg) {
+		return msg.split(root).join("<workspace>").trim();
+	}
+	return {
+		async status(agentId) {
+			const root = rootFor(agentId);
+			if (!isRepo(root)) return {
+				agentId,
+				isRepo: false,
+				clean: true
+			};
+			const s = await simpleGit(root).status();
+			const files = s.files.slice(0, MAX_STATUS_FILES).map((f) => ({
+				path: f.path,
+				index: f.index,
+				workingDir: f.working_dir
+			}));
+			return {
+				agentId,
+				isRepo: true,
+				clean: s.isClean(),
+				...s.current ? { branch: s.current } : {},
+				...s.tracking ? { tracking: s.tracking } : {},
+				ahead: s.ahead,
+				behind: s.behind,
+				...files.length ? { files } : {},
+				...s.files.length > files.length ? { truncated: true } : {}
+			};
+		},
+		async pull(agentId) {
+			const root = rootFor(agentId);
+			if (!isRepo(root)) return {
+				agentId,
+				isRepo: false,
+				ok: false,
+				detail: "workspace is not a git checkout"
+			};
+			let timer;
+			try {
+				const res = await Promise.race([simpleGit(root).pull(["--ff-only"]), new Promise((_, rej) => {
+					timer = setTimeout(() => rej(/* @__PURE__ */ new Error("pull timed out")), PULL_TIMEOUT_MS);
+				})]);
+				const changed = res.files.length;
+				return {
+					agentId,
+					isRepo: true,
+					ok: true,
+					changed,
+					insertions: res.summary.insertions,
+					deletions: res.summary.deletions,
+					detail: changed > 0 ? `Fast-forwarded — updated ${changed} file${changed === 1 ? "" : "s"}.` : "Already up to date."
+				};
+			} catch (err) {
+				return {
+					agentId,
+					isRepo: true,
+					ok: false,
+					detail: scrub(root, err?.message ?? "pull failed")
+				};
+			} finally {
+				if (timer) clearTimeout(timer);
+			}
+		}
+	};
+}
+//#endregion
 //#region src/cp/cp-cron.ts
 /**
 * `CpCronRegistry` — the daemon's set of CP-pushed crons, keyed by `cronId`
@@ -84368,6 +84524,7 @@ var Daemon = class Daemon {
 			configApply: this.cpConfigApply(),
 			sessionRead: createSessionReader(this.store),
 			workspaceRead: createWorkspaceReader((id) => this.agents.get(id)?.workspace.path),
+			workspaceGit: createWorkspaceGit((id) => this.agents.get(id)?.workspace.path),
 			clock: systemClock,
 			connect: () => ClientTransport.dial(url),
 			log: this.log