agent-yes 1.262.0 → 1.263.0

package/ts/serve.ts

@@ -1,4 +1,15 @@
-import { appendFile, mkdir, open, readdir, readFile, stat, unlink, writeFile } from "fs/promises";
+import {
+  appendFile,
+  mkdir,
+  open,
+  readdir,
+  readFile,
+  rename,
+  rm,
+  stat,
+  unlink,
+  writeFile,
+} from "fs/promises";
 import { existsSync, renameSync, watch, writeFileSync } from "node:fs";
 import { execFileSync } from "node:child_process";
 import { fileURLToPath } from "node:url";
@@ -566,6 +577,38 @@ async function runCapture(
   }
 }
 
+// A non-GitHub git source (gitlab, self-hosted, …) for /api/spawn's raw-clone
+// path. github.com inputs return null — those go through the provision module
+// (gh auth, setup-repo.sh). Accepts scp-style git@host:path, ssh://, git://,
+// http(s):// — bare owner/repo is github-first and never lands here.
+export function parseGitUrl(s: string): { url: string; owner: string; repo: string } | null {
+  let host = "";
+  let pathPart = "";
+  const scp = /^git@([^:/\s]+):([^\s]+?)(?:\.git)?\/?$/.exec(s);
+  if (scp) {
+    host = scp[1]!;
+    pathPart = scp[2]!;
+  } else {
+    let u: URL;
+    try {
+      u = new URL(s);
+    } catch {
+      return null;
+    }
+    if (!/^(https?|ssh|git)$/.test(u.protocol.replace(":", ""))) return null;
+    host = u.hostname;
+    pathPart = u.pathname.replace(/^\/+|\/+$/g, "").replace(/\.git$/, "");
+  }
+  if (/(^|\.)github\.com$/i.test(host)) return null;
+  const segs = pathPart.split("/").filter(Boolean);
+  if (segs.length < 2) return null;
+  const owner = segs[segs.length - 2]!;
+  const repo = segs[segs.length - 1]!.replace(/\.git$/, "");
+  if (!owner || !repo || owner === "." || owner === ".." || repo === "." || repo === "..")
+    return null;
+  return { url: s.replace(/\/+$/, ""), owner, repo };
+}
+
 // 60s memo for /api/ws/repos' gh side (see the endpoint for why).
 let ghRepoListMemo: { t: number; ok: boolean; repos: string[]; error?: string } | null = null;
 
@@ -4024,6 +4067,7 @@ export async function cmdServe(rest: string[]): Promise<number> {
         prompt?: string;
         yes?: boolean;
         create?: boolean;
+        branch?: string; // raw-clone path only (github specs embed the branch in `from`)
         fork?: { fromCwd?: string; branch?: string };
       };
       try {
@@ -4161,6 +4205,105 @@ export async function cmdServe(rest: string[]): Promise<number> {
           );
         cwd = result.folder;
         provisioned = { action: result.action, folder: result.folder };
+      } else if (from && parseGitUrl(from)) {
+        // Non-GitHub git URL (gitlab, self-hosted, …): raw `git clone` into the
+        // standard layout <wsRoot>/<owner>/<repo>/tree/<branch> — no provision
+        // module, no setup-repo.sh. Same admission gates as the github path:
+        // provision hook first (it may select credentials), else the allowlist.
+        const gitSrc = parseGitUrl(from)!;
+        const branch = typeof body.branch === "string" ? body.branch.trim() : "";
+        // the branch lands in a filesystem path (tree/<branch>) — no empty/./..
+        // segments, no option-looking names
+        const badBranch = (b: string) =>
+          b.startsWith("-") || b.split("/").some((s) => !s || s === "." || s === "..");
+        if (branch && badBranch(branch))
+          return new Response(`invalid branch name: ${branch}`, { status: 400 });
+        const gitHook = await runProvisionHook(getProvisionRoot() ?? homedir(), {
+          KOHO_ACTION: "from",
+          KOHO_SOURCE: from,
+          KOHO_OWNER: gitSrc.owner,
+          KOHO_REPO: gitSrc.repo,
+          KOHO_BRANCH: branch,
+          KOHO_WS_ROOT: getProvisionRoot() ?? "",
+        });
+        if (gitHook.ran) {
+          if (!gitHook.ok)
+            return new Response(
+              `provision hook denied '${gitSrc.owner}/${gitSrc.repo}' (exit ${gitHook.code})` +
+                (gitHook.detail ? `:\n${gitHook.detail}` : ""),
+              { status: 403 },
+            );
+        } else if (!isProvisionAllowed(gitSrc.owner, gitSrc.repo)) {
+          return new Response(
+            `provisioning '${gitSrc.owner}/${gitSrc.repo}' is not allowed — add the owner to ` +
+              `provisionAllowlist in ~/.agent-yes/config.json (or "*" to allow all), ` +
+              `or set a provisionHook to gate it yourself`,
+            { status: 403 },
+          );
+        }
+        const wsRootDir = getProvisionRoot() ?? path.join(homedir(), "ws");
+        const base = path.join(wsRootDir, gitSrc.owner, gitSrc.repo, "tree");
+        const destFor = (b: string) => path.join(base, b);
+        if (branch && existsSync(path.join(destFor(branch), ".git"))) {
+          // already provisioned — reuse; a fetch/pull is the agent's business
+          cwd = destFor(branch);
+          provisioned = { action: "existing", folder: cwd };
+        } else {
+          const tmp = path.join(base, `.clone-${process.pid}-${Date.now().toString(36)}`);
+          try {
+            await mkdir(base, { recursive: true });
+          } catch (e) {
+            return new Response(`cannot create ${base}: ${(e as Error).message}`, { status: 500 });
+          }
+          const cloneMs = 300_000;
+          let created = false;
+          let r = await runCapture(
+            branch
+              ? ["git", "clone", "--branch", branch, "--", gitSrc.url, tmp]
+              : ["git", "clone", "--", gitSrc.url, tmp],
+            { timeoutMs: cloneMs },
+          );
+          if (!r.ok && branch && body.create === true) {
+            // branch may not exist yet — clone the default and branch off it
+            await rm(tmp, { recursive: true, force: true }).catch(() => {});
+            r = await runCapture(["git", "clone", "--", gitSrc.url, tmp], { timeoutMs: cloneMs });
+            if (r.ok) {
+              const co = await runCapture(["git", "-C", tmp, "checkout", "-b", branch]);
+              if (!co.ok) r = co;
+              else created = true;
+            }
+          }
+          if (!r.ok) {
+            await rm(tmp, { recursive: true, force: true }).catch(() => {});
+            return new Response(
+              `git clone failed: ${(r.stderr.trim() || "unknown").slice(0, 500)}` +
+                (branch && body.create !== true
+                  ? "\n(if the branch doesn't exist yet, retry with create:true)"
+                  : ""),
+              { status: 502 },
+            );
+          }
+          const head = await runCapture(["git", "-C", tmp, "rev-parse", "--abbrev-ref", "HEAD"]);
+          let actual = branch || (head.ok ? head.stdout.trim() : "") || "main";
+          if (badBranch(actual)) actual = "main";
+          const dest = destFor(actual);
+          if (existsSync(dest)) {
+            // raced/already there — keep the existing checkout, drop ours
+            await rm(tmp, { recursive: true, force: true }).catch(() => {});
+          } else {
+            try {
+              await mkdir(path.dirname(dest), { recursive: true });
+              await rename(tmp, dest);
+            } catch (e) {
+              await rm(tmp, { recursive: true, force: true }).catch(() => {});
+              return new Response(`cannot place checkout at ${dest}: ${(e as Error).message}`, {
+                status: 500,
+              });
+            }
+          }
+          cwd = dest;
+          provisioned = { action: created ? "cloned+new-branch" : "cloned", folder: dest };
+        }
       } else if (from) {
         type Spec = { owner: string; repo: string; branch: string };
         let prov: {

package/ts/subcommands.ts

@@ -12,7 +12,9 @@
  */
 
 import { randomBytes } from "crypto";
+import { spawn } from "child_process";
 import { appendFile, mkdir, open, readFile, stat, writeFile } from "fs/promises";
+import { fileURLToPath } from "node:url";
 import ms from "ms";
 import { homedir } from "os";
 import path from "path";
@@ -442,6 +444,8 @@ const SUBCOMMANDS = new Set([
   "expose",
   "callback",
   "reap",
+  "deepseek",
+  "ds",
   "help",
 ]);
 
@@ -512,6 +516,42 @@ export function isUnknownManagerToken(
   return !supportedClis.includes(rawArg);
 }
 
+/**
+ * Write to stdout and wait until it has actually been handed off.
+ *
+ * The CLI ends with `process.exit()`, which DISCARDS bytes still sitting in the
+ * pipe buffer. Writing to a file completes synchronously so this never showed
+ * there, but any consumer that PIPES us silently lost everything past 64KiB.
+ * Measured on `ay ls --json` with a large fleet (symval CTO, 2026-08-05):
+ *
+ *     ay ls --json > file    118055 bytes, valid JSON
+ *     ay ls --json | consumer 65536 bytes, cut mid-multibyte — will not parse
+ *
+ * The truncation is invisible to the caller: it looks exactly like a small
+ * fleet, and an orchestrator that parses this reported 27 of 71 agents.
+ *
+ * Only capturing the REAL write's completion works. Probing afterwards with an
+ * empty `write("")` — by return value, by drain event, or by callback — reports
+ * ready while the big write is still queued (all three verified failing), so do
+ * not "simplify" this into a flush helper at the exit site.
+ */
+async function writeStdoutFlushed(text: string): Promise<void> {
+  // Use the WRITE'S OWN RETURN VALUE, not a probe afterwards. `false` means the
+  // pipe buffer is full and bytes are still queued; only then do we wait.
+  //
+  // Deliberately `=== false`: a stubbed/mocked stdout (tests, embedders) returns
+  // undefined, and treating that as backpressure made this await forever — it
+  // broke 5 specs before the strict compare went in. The timeout is a second
+  // guarantee that a stuck consumer can never hang the CLI.
+  const flushed = process.stdout.write(text);
+  if (flushed === false) {
+    await Promise.race([
+      new Promise<void>((resolve) => process.stdout.once("drain", () => resolve())),
+      new Promise<void>((resolve) => setTimeout(resolve, 2000)),
+    ]);
+  }
+}
+
 /**
  * Top-level entry. Returns the desired process exit code, or null if argv
  * is not a subcommand invocation.
@@ -629,6 +669,9 @@ export async function runSubcommand(argv: string[]): Promise<number | null> {
         await reaper.sweep();
         return 0;
       }
+      case "deepseek":
+      case "ds":
+        return cmdDeepseek(rest);
       case "help":
         return cmdHelp(managerCommands);
       default:
@@ -641,6 +684,47 @@ export async function runSubcommand(argv: string[]): Promise<number | null> {
   }
 }
 
+// ---------------------------------------------------------------------------
+// ay deepseek / ay ds
+// ---------------------------------------------------------------------------
+
+/**
+ * `ay deepseek [-- <args>…]` / `ay ds …`: run the local DeepSeek adapter that
+ * bridges Codex's Responses API to DeepSeek's chat completions, then spawn
+ * `codex` pointed at it. The adapter script lives in this package's
+ * `scripts/deepseek-codex.ts` and is Bun-only (Bun.serve / Bun.spawn), so it is
+ * re-exec'd via the same bun runtime that's running us — never imported into
+ * this process. Extra args are forwarded verbatim to `codex`.
+ */
+export function cmdDeepseek(rest: string[]): Promise<number> {
+  const root = path.join(path.dirname(fileURLToPath(import.meta.url)), "..");
+  const script = path.join(root, "scripts", "deepseek-codex.ts");
+  const bunBin = process.execPath.split(/[/\\]/).at(-1)?.startsWith("bun")
+    ? process.execPath
+    : "bun";
+  const child = spawn(bunBin, [script, ...rest], {
+    cwd: process.cwd(),
+    env: { ...process.env, AGENT_YES_BIN: process.argv[1] },
+    stdio: "inherit",
+  });
+  return new Promise((resolve) => {
+    child.on("error", (err) => {
+      process.stderr.write(`ay deepseek: failed to start: ${err.message}\n`);
+      resolve(1);
+    });
+    child.on("exit", (code, signal) => {
+      if (signal) {
+        resolve(128 + (signal === "SIGINT" ? 2 : signal === "SIGTERM" ? 15 : 1));
+      } else {
+        resolve(code ?? 1);
+      }
+    });
+    for (const signal of ["SIGINT", "SIGTERM"] as const) {
+      process.on(signal, () => child.kill(signal));
+    }
+  });
+}
+
 // ---------------------------------------------------------------------------
 // ay help
 // ---------------------------------------------------------------------------
@@ -747,6 +831,7 @@ export async function cmdHelp(managerCommands = true): Promise<number> {
       `  ay result <keyword> [--wait]        pull an agent's structured result envelope\n` +
       `  ay result set '<json>'              (inside an agent) deposit your result envelope\n` +
       `  ay reap                             kill process groups leaked by dead agents\n` +
+      `  ay deepseek|ds [-- <codex args>]    run codex via the local DeepSeek adapter (DEEPSEEK_API_KEY)\n` +
       wsLines +
       `\n` +
       `Remote:\n` +
@@ -1849,7 +1934,7 @@ async function cmdLs(rest: string[]): Promise<number> {
     const enriched = await Promise.all(
       records.map(async (r) => ({ ...r, ...(await deriveLiveState(r)) })),
     );
-    process.stdout.write(JSON.stringify(enriched, null, 2) + "\n");
+    await writeStdoutFlushed(JSON.stringify(enriched, null, 2) + "\n");
     return 0;
   }
 
@@ -3222,6 +3307,15 @@ async function cmdSend(rest: string[]): Promise<number> {
     })
     .help(false)
     .version(false)
+    // An UNKNOWN flag must be an error, never a silent reinterpretation of the
+    // message. yargs otherwise swallows `--body-file /tmp/x` as an ad-hoc option
+    // whose VALUE is the next token — which removes the positional entirely and
+    // sends an EMPTY body. That failure is invisible from both ends: the sender
+    // sees a normal exit, the recipient sees a blank message and reads it as an
+    // idle lane. Observed 2026-07-30: four consecutive replies vanished this way,
+    // and the receiving lane concluded the sender had stopped working and began
+    // taking over the work.
+    .strictOptions()
     .exitProcess(false);
 
   const argv = await y.parseAsync();
@@ -3238,6 +3332,17 @@ async function cmdSend(rest: string[]): Promise<number> {
   if (!keyword)
     throw new Error("usage: ay send <keyword> <msg|-> [--code=enter|esc|ctrl-c|ctrl-y|tab|none]");
 
+  // Second line of defence, independent of how the message went missing: never
+  // deliver nothing. Sending an empty body is never what anyone meant, and its
+  // whole cost is paid by the RECIPIENT, who cannot tell "no message" from
+  // "nothing to say". `-` is exempt here and validated after stdin is read.
+  if (rawMessage !== "-" && rawMessage.trim() === "") {
+    throw new Error(
+      "ay send: refusing to send an empty message. Pass the text as a single argument, " +
+        "or use `-` to read the body from stdin (e.g. `ay send <keyword> - < file.txt`).",
+    );
+  }
+
   const codeName = argv.code.toLowerCase();
   {
     const remote = await resolveRemoteSpec(keyword);
@@ -3271,6 +3376,9 @@ async function cmdSend(rest: string[]): Promise<number> {
     const chunks: Buffer[] = [];
     for await (const chunk of process.stdin) chunks.push(chunk as Buffer);
     body = Buffer.concat(chunks).toString("utf-8").trimEnd();
+    if (body.trim() === "") {
+      throw new Error("ay send: refusing to send an empty message (stdin was empty).");
+    }
   } else {
     body = rawMessage;
   }

package/dist/subcommands-D6O9uRvN.js

@@ -1,10 +0,0 @@
-import "./logger-CDIsZ-Pp.js";
-import "./globalPidIndex-pwp7Vb7o.js";
-import "./messageLog-BYFwioFY.js";
-import "./e2e-CUMZC53I.js";
-import "./configShared-DtHMBCl7.js";
-import { A as readPtysize, B as runSubcommand, C as lastStdinAt, D as readAgentPtysize, E as menuSelectKeys, F as renderRawLogLines, G as waitForLogQuiet, H as stdinActivityPath, I as resolveOne, K as writeKeysPaced, L as resolveReadWindow, M as recentReadEdges, N as renderLogTailLines, O as readLogForRender, P as renderRawLog, R as resolveResumeArgs, S as isUserTyping, T as matchKeyword, U as stopTipForCli, V as snapshotStatus, W as submitAndConfirm, _ as isExitRequest, a as backoffWhileTyping, b as isSubcommand, c as cursorAbs, d as extractBadges, f as extractMenu, g as isAgentStuck, h as finalizedLines, i as TYPING_WINDOW_MS, j as recentMessageEdges, k as readNotes, l as deriveLiveState, m as extractTaskCounts, n as MAX_RENDER_BYTES, o as cmdHelp, p as extractNeedsInput, q as writeToIpc, r as READ_PAGE_DEFAULT, s as controlCodeFromName, t as GRACEFUL_EXIT_COMMANDS, u as deriveLiveStatus, v as isPidAlive, w as listRecords, x as isUnknownManagerToken, y as isSlashCommand, z as restartHintLines } from "./subcommands-Zk3brdKt.js";
-import "./webrtcLink-CS4D-3G1.js";
-import "./remotes-Cn-wszbK.js";
-
-export { cmdHelp, isSubcommand, isUnknownManagerToken, runSubcommand };

package/dist/trayApp-C6U7Hghi.js

@@ -1,5 +0,0 @@
-import "./versionChecker-D-WLKAN6.js";
-import "./rustBinary-_qRGhAa5.js";
-import { a as trayHiddenMarker, i as launchTray, n as hasDesktop, r as isTrayHidden, t as cmdTray } from "./trayApp-DtThjl0_.js";
-
-export { cmdTray };