jeo-code 0.12.7 → 0.12.9

package/src/agent/notify/session-endpoint.ts

@@ -44,6 +44,7 @@ import * as fs from "node:fs/promises";
 import type { Server, ServerWebSocket } from "bun";
 import { readGlobalConfig } from "../state";
 import { notifySessionEndpointPath, notifySessionsDir } from "./paths";
+import { resolveDiscordArtifactStage, type DiscordArtifactPaths } from "./discord-artifacts";
 import type { SubagentRecord, SubagentRegistry } from "../subagent-registry";
 
 const SNAPSHOT_POLL_MS = 1_200;
@@ -75,6 +76,13 @@ export class SessionNotifyEndpoint {
   private server: Server<undefined> | undefined;
 
   private readonly sockets = new Set<ServerWebSocket<undefined>>();
+  private readonly relaySockets = new Set<ServerWebSocket<undefined>>();
+  private readonly pendingRelay = new Map<ServerWebSocket<undefined>, number>();
+  private relayRequestGeneration = 0;
+  private readonly remoteControllers = new Map<ServerWebSocket<undefined>, { reqId: string; controller: AbortController }>();
+  private relayGeneration = 0;
+  private discordControlEnabled = false;
+  private discordControlGeneration = 0;
   private pollTimer: ReturnType<typeof setInterval> | undefined;
   private lastSnapshotJson = "";
   /** `undefined` between turns — subagent requests report an empty registry. */
@@ -85,6 +93,8 @@ export class SessionNotifyEndpoint {
 
   /** Registered by launch.ts; absent or rejected handlers return a failed ACK. */
   onUserMessage: ((msg: RemoteUserMessage) => void | boolean | Promise<void | boolean>) | undefined;
+  onRemoteRequest: ((text: string, finish: (text?: string, artifactsAllowed?: boolean) => void, signal: AbortSignal, stage?: DiscordArtifactPaths) => boolean) | undefined;
+  onRegistryMutation: (() => void) | undefined;
   onConfigCommand: ((cmd: RemoteConfigCommand) => void) | undefined;
 
   constructor(
@@ -153,6 +163,61 @@ export class SessionNotifyEndpoint {
     this.broadcast(JSON.stringify({ type: "turn_stream", sessionId: this.sessionId, phase: "finalized", text }));
   }
 
+  /** Revoke current subscriptions before asking a daemon to change destination. */
+  requestLocalRelay(destination: string): number {
+    this.relaySockets.clear();
+    this.relayGeneration++;
+    this.pendingRelay.clear();
+    const generation = ++this.relayRequestGeneration;
+    const json = JSON.stringify({ type: "local_relay_control", sessionId: this.sessionId, destination, generation });
+    let sent = 0;
+    for (const ws of this.sockets) {
+      try { if (ws.send(json) > 0) { if (destination !== "off") this.pendingRelay.set(ws, generation); sent++; continue; } } catch {}
+      this.sockets.delete(ws);
+      this.remoteControllers.get(ws)?.controller.abort();
+      this.remoteControllers.delete(ws);
+      try { ws.terminate(); } catch { try { ws.close(); } catch {} }
+    }
+    return sent;
+  }
+
+  /** Snapshot eligibility before a turn; changes invalidate its relay. */
+  localRelayGeneration(): number | undefined {
+    return this.relaySockets.size ? this.relayGeneration : undefined;
+  }
+
+  sendLocalFinal(text: string, generation: number): void {
+    if (generation !== this.relayGeneration) return;
+    const json = JSON.stringify({ type: "local_final", sessionId: this.sessionId, text });
+    for (const ws of this.relaySockets) {
+      try { ws.send(json); } catch {}
+    }
+  }
+
+  private sendDiscordControl(ws: ServerWebSocket<undefined>): void {
+    try {
+      const frame = JSON.stringify({ type: "discord_control", sessionId: this.sessionId, enabled: this.discordControlEnabled, generation: this.discordControlGeneration });
+      if (ws.send(frame) > 0) return;
+    } catch {}
+    this.sockets.delete(ws);
+    this.pendingRelay.delete(ws);
+    if (this.relaySockets.delete(ws)) this.relayGeneration++;
+    this.remoteControllers.get(ws)?.controller.abort();
+    this.remoteControllers.delete(ws);
+    try { ws.terminate(); } catch { try { ws.close(); } catch {} }
+  }
+
+  setDiscordControlEnabled(enabled: boolean): void {
+    if (enabled === this.discordControlEnabled) return;
+    this.discordControlEnabled = enabled;
+    this.discordControlGeneration++;
+    for (const ws of this.sockets) this.sendDiscordControl(ws);
+    if (!enabled) {
+      for (const remote of this.remoteControllers.values()) remote.controller.abort();
+      this.remoteControllers.clear();
+    }
+  }
+
   private async handleMessage(ws: ServerWebSocket<undefined>, raw: string | Buffer): Promise<void> {
     if (Buffer.byteLength(raw) > MAX_INBOUND_BYTES) return;
     let msg: Record<string, unknown>;
@@ -162,25 +227,71 @@ export class SessionNotifyEndpoint {
       return;
     }
     if (!msg || typeof msg !== "object" || Array.isArray(msg)) return;
-    if (msg.sessionId !== undefined && msg.sessionId !== this.sessionId) return;
+    if (msg.type !== "remote_request" && msg.sessionId !== undefined && msg.sessionId !== this.sessionId) return;
+    if (msg.type === "remote_request") {
+      const reqId = msg.reqId;
+      let ok = false;
+      const onlyExpectedFields = Object.keys(msg).every(key => ["type", "sessionId", "reqId", "text", "staged", "controlGeneration"].includes(key));
+      if (onlyExpectedFields && this.discordControlEnabled && msg.controlGeneration === this.discordControlGeneration && msg.sessionId === this.sessionId && typeof reqId === "string" && reqId.length > 0 && reqId.length <= 256 &&
+          typeof msg.text === "string" && !!msg.text.trim() && !msg.text.includes("\u0003") && !/^[\/!$]/.test(msg.text.trimStart()) && (msg.staged === undefined || msg.staged === true) && this.onRemoteRequest && !this.remoteControllers.has(ws)) {
+        let finished = false;
+        const controlGeneration = this.discordControlGeneration;
+        const controller = new AbortController();
+        this.remoteControllers.set(ws, { reqId, controller });
+        let stage: DiscordArtifactPaths | undefined;
+        const finish = (text?: string, artifactsAllowed = false): void => {
+          if (finished) return;
+          finished = true;
+          if (this.remoteControllers.get(ws)?.controller === controller) this.remoteControllers.delete(ws);
+          if (!this.sockets.has(ws)) return;
+          if (!this.discordControlEnabled || controller.signal.aborted || controlGeneration !== this.discordControlGeneration) text = undefined;
+          if (!stage) artifactsAllowed = false;
+          try { ws.send(JSON.stringify({ type: "remote_final", sessionId: this.sessionId, reqId, controlGeneration, ok: text !== undefined, artifactsAllowed: text !== undefined && artifactsAllowed, ...(text !== undefined ? { text } : {}) })); } catch {}
+        };
+        try {
+          if (msg.staged === true) stage = await resolveDiscordArtifactStage(this.sessionId, reqId);
+          if (this.discordControlEnabled && controlGeneration === this.discordControlGeneration && !controller.signal.aborted && this.sockets.has(ws)) {
+            ok = this.onRemoteRequest(msg.text, finish, controller.signal, stage);
+          }
+        } catch {}
+        if (!ok && this.remoteControllers.get(ws)?.controller === controller) this.remoteControllers.delete(ws);
+      }
+      try { ws.send(JSON.stringify({ type: "ack", reqId, ok })); } catch {}
+      return;
+    }
+    if (msg.type === "remote_cancel" && msg.sessionId === this.sessionId && typeof msg.reqId === "string") {
+      const remote = this.remoteControllers.get(ws);
+      if (remote?.reqId === msg.reqId) remote.controller.abort();
+      return;
+    }
+    if (msg.type === "local_relay" && msg.sessionId === this.sessionId && typeof msg.enabled === "boolean") {
+      const allowed = !msg.enabled || (typeof msg.generation === "number" && this.pendingRelay.get(ws) === msg.generation && msg.generation === this.relayRequestGeneration);
+      if (allowed && msg.enabled) this.relaySockets.add(ws);
+      else if (!msg.enabled) this.relaySockets.delete(ws);
+      if (allowed) { this.pendingRelay.delete(ws); this.relayGeneration++; }
+      try { ws.send(JSON.stringify({ type: "ack", reqId: msg.reqId, ok: allowed })); } catch {}
+      return;
+    }
     if (msg.type === "list") {
       try {
         ws.send(JSON.stringify(this.snapshot()));
       } catch {}
       return;
     }
-    if (msg.type === "steer") {
+    if (msg.type === "steer" || msg.type === "discord_steer") {
       const id = typeof msg.id === "string" ? msg.id : "";
       const message = typeof msg.message === "string" ? msg.message : "";
-      const ok = !!(id && message && this.registry?.steer(id, message));
+      const ok = !!((msg.type === "steer" || (this.discordControlEnabled && msg.sessionId === this.sessionId && msg.controlGeneration === this.discordControlGeneration)) && id && message && this.registry?.steer(id, message));
+      if (ok) this.onRegistryMutation?.();
       try {
         ws.send(JSON.stringify({ type: "ack", reqId: msg.reqId, ok }));
       } catch {}
       return;
     }
-    if (msg.type === "cancel") {
+    if (msg.type === "cancel" || msg.type === "discord_cancel") {
       const ids = Array.isArray(msg.ids) ? msg.ids.filter((x): x is string => typeof x === "string") : [];
-      const cancelled = ids.length > 0 ? (this.registry?.cancel(ids) ?? []) : [];
+      const cancelled = (msg.type === "cancel" || (this.discordControlEnabled && msg.sessionId === this.sessionId && msg.controlGeneration === this.discordControlGeneration)) && ids.length > 0 ? (this.registry?.cancel(ids) ?? []) : [];
+      if (cancelled.length) this.onRegistryMutation?.();
       try {
         ws.send(JSON.stringify({ type: "ack", reqId: msg.reqId, ok: cancelled.length > 0 }));
         ws.send(JSON.stringify(this.snapshot()));
@@ -232,10 +343,15 @@ export class SessionNotifyEndpoint {
             ws.send(JSON.stringify(this.snapshot()));
             if (this.identityFrame) ws.send(this.identityFrame);
           } catch {}
+          this.sendDiscordControl(ws);
         },
         message: (ws, raw) => { void this.handleMessage(ws, raw); },
         close: ws => {
           this.sockets.delete(ws);
+          this.pendingRelay.delete(ws);
+          this.remoteControllers.get(ws)?.controller.abort();
+          this.remoteControllers.delete(ws);
+          if (this.relaySockets.delete(ws)) this.relayGeneration++;
         },
       },
     });
@@ -279,6 +395,12 @@ export class SessionNotifyEndpoint {
       clearInterval(this.pollTimer);
       this.pollTimer = undefined;
     }
+    this.setDiscordControlEnabled(false);
+    this.relaySockets.clear();
+    this.pendingRelay.clear();
+    this.relayGeneration++;
+    for (const remote of this.remoteControllers.values()) remote.controller.abort();
+    this.remoteControllers.clear();
     for (const ws of this.sockets) {
       try {
         ws.close();

package/src/agent/session.ts

@@ -76,7 +76,7 @@ export function newSessionId(): string {
 }
 
 export function sessionsDir(cwd = process.cwd()): string {
-  return path.join(getLocalJeoDir(cwd), "sessions");
+  return process.env.JEO_SESSION_DIR || path.join(getLocalJeoDir(cwd), "sessions");
 }
 
 export function sessionPath(id: string, cwd = process.cwd()): string {
@@ -86,9 +86,11 @@ export function sessionPath(id: string, cwd = process.cwd()): string {
 export async function createSession(
   cwd = process.cwd(),
   id = newSessionId(),
-  model?: string
+  model?: string,
+  directory = sessionsDir(cwd),
+  exclusive = false,
 ): Promise<{ id: string; path: string }> {
-  const dir = sessionsDir(cwd);
+  const dir = directory;
   await fs.mkdir(dir, { recursive: true });
 
   const header: SessionHeader = {
@@ -100,8 +102,8 @@ export async function createSession(
     ...(model ? { model } : {}),
   };
 
-  const file = sessionPath(id, cwd);
-  await fs.writeFile(file, JSON.stringify(header) + "\n", "utf8");
+  const file = path.join(dir, `${id}.jsonl`);
+  await fs.writeFile(file, JSON.stringify(header) + "\n", { encoding: "utf8", ...(exclusive ? { flag: "wx", mode: 0o600 } : {}) });
 
   return { id, path: file };
 }

package/src/cli/runner.ts

@@ -119,6 +119,15 @@ export const COMMANDS: readonly CommandSpec[] = [
       return args => m.runNotifyCommand(args);
     },
   },
+  {
+    name: "messenger",
+    summary: "Run or configure the bidirectional Discord, Telegram, and Slack agent gateway.",
+    usage: "messenger [setup|check|run] --config <file> [--channel ID] [--user ID] [--tools LIST] [--artifacts] [--service]",
+    loader: async () => {
+      const m = await import("../commands/messenger");
+      return args => m.runMessengerCommand(args);
+    },
+  },
   {
     name: "daemon",
     summary: "Manage the shared Telegram/Discord/Slack notification daemon.",

package/src/cli.ts

@@ -44,6 +44,10 @@ const fatal = (err: unknown): never => {
 };
 process.on("uncaughtException", fatal);
 process.on("unhandledRejection", fatal);
+// Bun 1.4 may report a closed downstream pipe as a stream error event instead of
+// promoting it to uncaughtException. Keep both runtime shapes on the same quiet path.
+process.stdout.on("error", fatal);
+process.stderr.on("error", fatal);
 
 try {
   const code = await dispatch(process.argv.slice(2), { appName: APP_NAME, version: VERSION });

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;