jeo-code 0.12.7 → 0.12.8

package/src/commands/launch/agy-turn.ts

@@ -9,13 +9,20 @@ export interface AgySessionTurnOptions extends Omit<AgyTurnOptions, "conversatio
 }
 
 /** An explicit full-agent turn: no raw-model loop, credential fallback, or tool replay. */
-export async function runAgySessionTurn(options: AgySessionTurnOptions): Promise<AgyTurnResult> {
+export async function runAgySessionTurn(options: AgySessionTurnOptions, deps: {
+  loadSession?: typeof loadSession;
+  appendMessage?: typeof appendMessage;
+  appendAgySession?: typeof appendAgySession;
+  runAgyTurn?: typeof runAgyTurn;
+} = {}): Promise<AgyTurnResult> {
   const { history, sessionId, images, ...turn } = options;
+  const { loadSession: load = loadSession, appendMessage: append = appendMessage, appendAgySession: appendAgy = appendAgySession, runAgyTurn: run = runAgyTurn } = deps;
   if (images?.length) throw new Error("Image attachments are not supported by the official agy bridge");
   if (turn.signal?.aborted) throw new AgyCliError("Official CLI turn cancelled", "cancelled");
 
   const previousCount = history.reduce((count, message) => count + (message.role === "system" ? 0 : 1), 0);
-  const state = sessionId ? (await loadSession(sessionId, turn.cwd)).header.agy : undefined;
+  const state = sessionId ? (await load(sessionId, turn.cwd)).header.agy : undefined;
+  turn.signal?.throwIfAborted();
   // A non-CLI turn or compaction changes the cursor. Start fresh with text context
   // rather than resume a stale agent conversation or agy's unrelated latest one.
   let conversationId = state?.messageCount === previousCount ? state.conversationId : undefined;
@@ -33,26 +40,32 @@ export async function runAgySessionTurn(options: AgySessionTurnOptions): Promise
   }
 
   const user: Message = { role: "user", content: turn.prompt };
-  if (sessionId) await appendMessage(sessionId, user, turn.cwd);
+  if (sessionId) await append(sessionId, user, turn.cwd);
+  turn.signal?.throwIfAborted();
   history.push(user);
-  const result = await runAgyTurn({
+  const result = await run({
     ...turn,
     prompt,
     conversationId,
     onConversation: async id => {
+      turn.signal?.throwIfAborted();
       conversationId = id;
-      if (sessionId) await appendAgySession(sessionId, { conversationId: id, messageCount: previousCount + 1 }, turn.cwd);
+      if (sessionId) await appendAgy(sessionId, { conversationId: id, messageCount: previousCount + 1 }, turn.cwd);
+      turn.signal?.throwIfAborted();
     },
   });
+  turn.signal?.throwIfAborted();
 
   const assistant: Message = { role: "assistant", content: result.response };
   try {
-    if (sessionId) await appendMessage(sessionId, assistant, turn.cwd);
+    if (sessionId) await append(sessionId, assistant, turn.cwd);
+    turn.signal?.throwIfAborted();
     history.push(assistant);
-    if (sessionId) await appendAgySession(sessionId, {
+    if (sessionId) await appendAgy(sessionId, {
       conversationId: result.conversationId,
       messageCount: previousCount + 2,
     }, turn.cwd);
+    turn.signal?.throwIfAborted();
   } catch (error) {
     throw new Error(`Official CLI completed, but saving its jeo session failed: ${error instanceof Error ? error.message : String(error)}`, { cause: error });
   }

package/src/commands/launch/confirm.ts

@@ -0,0 +1,78 @@
+/** Confirm a sensitive action on an isolated local TTY; all other input denies. */
+export async function confirmLocalControl({
+  input,
+  output,
+  timeoutMs = 15_000,
+  warning = "Discord control grants authorized users the host session's tools and approval policy, including reading or changing files and running commands. This is not a sandbox.",
+  prompt = "Confirm Discord control: press y to allow, any other key to cancel.",
+}: {
+  input: NodeJS.ReadStream;
+  output: NodeJS.WriteStream;
+  timeoutMs?: number;
+  warning?: string;
+  prompt?: string;
+}): Promise<boolean> {
+  if (!input.isTTY || !output.isTTY || typeof input.setRawMode !== "function" || !Number.isFinite(timeoutMs) || timeoutMs <= 0) return false;
+  const wasRaw = !!input.isRaw;
+  const wasPaused = input.isPaused();
+  const dataListeners = input.rawListeners("data");
+  const keyListeners = input.rawListeners("keypress");
+  let deadline: ReturnType<typeof setTimeout> | undefined;
+  let quiet: ReturnType<typeof setTimeout> | undefined;
+  let phase: "drain" | "ready" | "candidate" = "drain";
+  let finished = false;
+  let resolveResult: (value: boolean) => void = () => {};
+  const result = new Promise<boolean>(resolve => { resolveResult = resolve; });
+  const finish = (accepted: boolean) => {
+    if (finished) return;
+    finished = true;
+    resolveResult(accepted);
+  };
+  const startQuietDrain = () => {
+    clearTimeout(quiet);
+    quiet = setTimeout(() => {
+      if (finished) return;
+      phase = "ready";
+      try { output.write(`${prompt}\n`); }
+      catch { finish(false); }
+    }, 200);
+  };
+  const onData = (chunk: string | Uint8Array) => {
+    if (phase === "drain") { startQuietDrain(); return; }
+    if (phase !== "ready" || (typeof chunk === "string" ? chunk !== "y" : chunk.length !== 1 || chunk[0] !== 0x79)) { finish(false); return; }
+    phase = "candidate";
+    quiet = setTimeout(() => finish(true), 200);
+  };
+  const onEnd = () => finish(false);
+  try {
+    input.pause();
+    for (const listener of dataListeners) input.removeListener("data", listener);
+    for (const listener of keyListeners) input.removeListener("keypress", listener);
+    input.setRawMode(true);
+    output.write(`${warning}\n`);
+    while (input.read() !== null) { /* discard input queued before the warning */ }
+    input.on("data", onData);
+    input.once("end", onEnd);
+    input.once("close", onEnd);
+    input.once("error", onEnd);
+    deadline = setTimeout(() => finish(false), timeoutMs);
+    startQuietDrain();
+    input.resume();
+    return await result;
+  } catch {
+    return false;
+  } finally {
+    clearTimeout(deadline);
+    clearTimeout(quiet);
+    input.pause();
+    input.removeListener("data", onData);
+    input.removeListener("end", onEnd);
+    input.removeListener("close", onEnd);
+    input.removeListener("error", onEnd);
+    for (const listener of dataListeners) input.on("data", listener);
+    for (const listener of keyListeners) input.on("keypress", listener);
+    try { input.setRawMode(wasRaw); } catch {}
+    if (wasPaused) input.pause();
+    else input.resume();
+  }
+}

package/src/commands/launch/flags.ts

@@ -23,6 +23,8 @@ export interface LaunchFlags {
   thinking?: ThinkLevel;
   errors: string[];
   print?: boolean;
+  literalPrompt?: boolean;
+  literalWorker?: boolean;
   appendSystemPromptRaw?: string;
   appendSystemPrompt?: string;
   noSkills: boolean;
@@ -160,6 +162,11 @@ export function parseFlags(args: string[], cwd: string = process.cwd()): LaunchF
       if (value) flags.skills = value;
       else flags.errors.push("--skills requires a value");
       i = nextIndex;
+    } else if (a === "--literal-prompt") {
+      flags.literalPrompt = true;
+    } else if (a === "--literal-worker") {
+      flags.literalWorker = true;
+      flags.literalPrompt = true;
     } else if (a === "--no-tools") {
       flags.noTools = true;
     } else if (a === "--tools" || a.startsWith("--tools=")) {

package/src/commands/launch/input.ts

@@ -34,6 +34,9 @@ interface AbortHarnessOptions {
   onScrollKey?: (dir: -1 | 1, page: boolean) => void;
   /** Invoked with printable keyboard input received while the live turn owns stdin. */
   onBufferedInput?: (chunk: string) => void;
+  /** Emergency-only input while an aborted turn is still unwinding. */
+  onBufferedInputAfterAbort?: (chunk: string) => void;
+  pasteActiveAfterAbort?: () => boolean;
   /** True while the input queue is inside a bracketed paste (mid-paste chunks
    *  carry no marker and must keep routing to the queue, not the noise path). */
   pasteActive?: () => boolean;
@@ -46,6 +49,15 @@ interface AbortHarnessOptions {
 export const PASTE_START = "\u001b[200~";
 export const PASTE_END = "\u001b[201~";
 
+/** Conservative paste signal; one-character chunks remain indistinguishable from typing. */
+export function isPasteLikeInputChunk(chunk: string): boolean {
+  let printable = 0;
+  for (const ch of stripPasteEscapes(chunk)) {
+    if ((ch >= " " || ch === "\t") && ++printable > 1) return true;
+  }
+  return false;
+}
+
 /** True when a stdin chunk is ONLY backspace bytes (DEL 0x7f or BS 0x08) — i.e. a
  *  standalone Backspace keystroke with nothing else. A backspace on an EMPTY input
  *  line is a no-op edit, but some Bun readline builds turn it into a spurious `close`
@@ -483,8 +495,13 @@ export function createInFlightAbortHarness(opts: AbortHarnessOptions = {}): InFl
   };
 
   const handleData = (chunk: string | Uint8Array) => {
-    if (!captureEsc || controller.signal.aborted) return;
+    if (!captureEsc) return;
     const raw = typeof chunk === "string" ? chunk : Buffer.from(chunk).toString("utf8");
+    if (controller.signal.aborted) {
+      if (!raw.includes(PASTE_START) && !opts.pasteActiveAfterAbort?.() && chunkHasCtrlC(raw)) handleSigint();
+      else opts.onBufferedInputAfterAbort?.(raw);
+      return;
+    }
     if (raw.includes(PASTE_START) || opts.pasteActive?.()) {
       opts.onBufferedInput?.(raw);
       return;