aegiscode 6.1.1 → 6.2.0

package/src/config.js

@@ -0,0 +1,163 @@
+'use strict';
+
+/**
+ * User config + permissions persistence (~/.aegiscode/config.json and
+ * permissions.json). Honors AEGISCODE_HOME so tests and side-by-side installs
+ * can redirect the data dir. Reads and writes are best-effort: a corrupt
+ * config falls back to defaults, and write failures never crash the session.
+ *
+ * Ported from aegiscodex-dev/src/config.js (ESM → CommonJS). The data dir was
+ * renamed ~/.aegiscodex → ~/.aegiscode and the override env var
+ * AEGISCODEX_HOME → AEGISCODE_HOME; `aegisDir` is the one shared helper every
+ * other module imports rather than recomputing the path.
+ */
+
+const fs = require('node:fs');
+const os = require('node:os');
+const path = require('node:path');
+
+/** Data directory: $AEGISCODE_HOME or ~/.aegiscode. */
+function aegisDir() {
+  const override = process.env.AEGISCODE_HOME;
+  if (override && String(override).trim()) return path.resolve(String(override).trim());
+  return path.join(os.homedir(), '.aegiscode');
+}
+
+function configPath() {
+  return path.join(aegisDir(), 'config.json');
+}
+
+/**
+ * True once the user has run before — the config file is written during
+ * onboarding (and on the first preference change). Used to gate the trust
+ * check + theme picker to a genuine first run: re-showing them every launch
+ * wiped the screen with the theme picker and discarded the prior session.
+ */
+function configExists() {
+  try { return fs.existsSync(configPath()); } catch { return false; }
+}
+
+function permissionsPath() {
+  return path.join(aegisDir(), 'permissions.json');
+}
+
+const DEFAULT_CONFIG = {
+  themeIndex: 1,   // Dark mode
+  model: 'sonnet',
+  // Phase 6: the full model table (seeded from src/models.js MODELS on first
+  // read by pickerModels()). 'currentModelId' mirrors `model` under the
+  // aegiscode- name so /model add/remove/switch stay compatible both ways.
+  models: null,
+  currentModelId: null,
+  effort: 'high',
+  vim: false,
+  lastCwd: '',
+};
+
+/** Read the config, falling back to defaults (never throws). */
+function loadConfig() {
+  try {
+    const raw = fs.readFileSync(configPath(), 'utf8');
+    const parsed = JSON.parse(raw);
+    if (parsed && typeof parsed === 'object') return { ...DEFAULT_CONFIG, ...parsed };
+  } catch {}
+  return { ...DEFAULT_CONFIG };
+}
+
+/**
+ * Merge a patch into the config on disk and return the merged config.
+ * A no-op that still returns the merged view when the data dir is unwritable.
+ */
+function updateConfig(patch) {
+  const next = { ...loadConfig(), ...patch };
+  try {
+    fs.mkdirSync(aegisDir(), { recursive: true });
+    // Write atomically-ish: tmp file + rename so a crash can't corrupt it.
+    const tmp = configPath() + '.tmp';
+    fs.writeFileSync(tmp, JSON.stringify(next, null, 2) + '\n');
+    fs.renameSync(tmp, configPath());
+  } catch (e) {
+    if (process.env.AEGIS_HIST_DEBUG) console.error('[config] write failed:', e);
+  }
+  return next;
+}
+
+// ── Permissions (~/.aegiscode/permissions.json) ─────────────────────────────
+
+const DEFAULT_PERMISSIONS = {
+  defaultMode: 'ask', // 'ask' | 'allow' | 'deny'
+  allow: [],          // ["Bash(npm run *)", "Edit(src/**)"]
+  deny: [],
+  ask: [],
+};
+
+/**
+ * Read permission rules, falling back to the empty default (never throws).
+ * `explicitAsk` is true only when the permissions file *explicitly* writes
+ * `"defaultMode": "ask"`. The file-free default is also 'ask', but it must
+ * not trigger a prompt on every call out of the box — evalPermission only
+ * consults explicitAsk, so the distinction matters.
+ */
+function loadPermissions() {
+  try {
+    const raw = fs.readFileSync(permissionsPath(), 'utf8');
+    const parsed = JSON.parse(raw);
+    if (parsed && typeof parsed === 'object') {
+      return {
+        ...DEFAULT_PERMISSIONS,
+        allow: Array.isArray(parsed.allow) ? parsed.allow : [],
+        deny: Array.isArray(parsed.deny) ? parsed.deny : [],
+        ask: Array.isArray(parsed.ask) ? parsed.ask : [],
+        defaultMode: parsed.defaultMode || DEFAULT_PERMISSIONS.defaultMode,
+        explicitAsk: parsed.defaultMode === 'ask',
+      };
+    }
+  } catch {}
+  return { ...DEFAULT_PERMISSIONS, allow: [], deny: [], ask: [], explicitAsk: false };
+}
+
+/** Persist permission rules. Returns the saved rules (or the input on failure). */
+function savePermissions(rules) {
+  try {
+    fs.mkdirSync(aegisDir(), { recursive: true });
+    const tmp = permissionsPath() + '.tmp';
+    fs.writeFileSync(tmp, JSON.stringify(rules, null, 2) + '\n');
+    fs.renameSync(tmp, permissionsPath());
+  } catch (e) {
+    if (process.env.AEGIS_HIST_DEBUG) console.error('[permissions] write failed:', e);
+  }
+  return rules;
+}
+
+/**
+ * Add a rule to a permission list if not already present.
+ * Returns { added, rules } — added is false when the rule already exists.
+ */
+function addPermissionRule(list, pattern, rules) {
+  const key = list === 'allow' || list === 'deny' || list === 'ask' ? list : 'allow';
+  const patterns = rules[key];
+  if (patterns.includes(pattern)) return { added: false, rules };
+  return { added: true, rules: { ...rules, [key]: [...patterns, pattern] } };
+}
+
+/** Remove a rule from a permission list. Returns { removed, rules }. */
+function removePermissionRule(list, pattern, rules) {
+  const key = list === 'allow' || list === 'deny' || list === 'ask' ? list : 'allow';
+  const patterns = rules[key].filter((p) => p !== pattern);
+  return { removed: patterns.length !== rules[key].length, rules: { ...rules, [key]: patterns } };
+}
+
+module.exports = {
+  aegisDir,
+  configPath,
+  configExists,
+  permissionsPath,
+  DEFAULT_CONFIG,
+  loadConfig,
+  updateConfig,
+  DEFAULT_PERMISSIONS,
+  loadPermissions,
+  savePermissions,
+  addPermissionRule,
+  removePermissionRule,
+};

package/src/deps.js

@@ -51,15 +51,28 @@ const toolsPath = resolveShared(path.join('mcp', 'tools.js'));
 // disagree about what a call consumed (test/cli-tools.test.mjs asserts the
 // function identity).
 const usagePath = resolveShared(path.join('desktop', 'renderer', 'usage.js'));
+// The desktop's agent-loop engine — persistent-shell exec, editFile/grep,
+// Task subagents — reused verbatim (src/engine.js scopes it to the 'aegis'
+// class) so the CLI's chat loop is the same tool loop as the GUI's, not a
+// second implementation that can drift out of step with it.
+const enginePath = resolveShared(path.join('desktop', 'lib', 'local', 'engine.js'));
+// Subagent role presets (/agents lists these; the model's task tool delegates
+// to them by name) — lives beside engine.js, staged into the same vendor dir.
+const agentsPath = resolveShared(path.join('desktop', 'lib', 'local', 'agents.js'));
 
 const { createClient } = require(clientPath);
 const { createTools } = require(toolsPath);
 const { usageTokens } = require(usagePath);
+const { createLocalEngine } = require(enginePath);
+const { agentRoles, agentRoleLabel } = require(agentsPath);
 
 module.exports = {
   createClient,
   createTools,
   usageTokens,
-  paths: { client: clientPath, tools: toolsPath, usage: usagePath },
+  createLocalEngine,
+  agentRoles,
+  agentRoleLabel,
+  paths: { client: clientPath, tools: toolsPath, usage: usagePath, engine: enginePath, agents: agentsPath },
   roots,
 };

package/src/devrun.js

@@ -0,0 +1,110 @@
+'use strict';
+
+/**
+ * /run support: sniff the project's dev command and run it in a captured
+ * sub-shell. Output streams to the transcript as it happens; the session loop
+ * can stop the process (Esc) via the returned job handle.
+ *
+ * Ported from aegiscodex-dev/src/devrun.js (ESM → CommonJS).
+ */
+
+const { spawn } = require('node:child_process');
+const fs = require('node:fs');
+const path = require('node:path');
+
+const MAX_STREAM_LINES = 40;
+
+/** Detect the most likely dev command for a project, or null. */
+function detectDevCommand(cwd = process.cwd()) {
+  const pkg = path.join(cwd, 'package.json');
+  if (fs.existsSync(pkg)) {
+    try {
+      const scripts = JSON.parse(fs.readFileSync(pkg, 'utf8')).scripts || {};
+      for (const name of ['dev', 'start', 'watch', 'serve']) {
+        if (typeof scripts[name] === 'string' && scripts[name].trim()) return `npm run ${name}`;
+      }
+    } catch {}
+    return 'npm start';
+  }
+  if (fs.existsSync(path.join(cwd, 'go.mod'))) return 'go run .';
+  if (fs.existsSync(path.join(cwd, 'Cargo.toml'))) return 'cargo run';
+  if (fs.existsSync(path.join(cwd, 'Makefile'))) return 'make';
+  if (fs.existsSync(path.join(cwd, 'pyproject.toml'))) return 'python -m <module>'; // honest: user picks
+  return null;
+}
+
+/**
+ * Run a shell command, streaming stdout/stderr lines to onLine. Returns a job:
+ *   { stop(), done: Promise<{ code, stopped }> }
+ * The child is killed (SIGTERM) when stop() is called.
+ */
+function runDevServer(command, { onLine, signal, cwd } = {}) {
+  // detached + kill(-pid) so the whole process group dies (shell + child),
+  // otherwise a stopped dev server leaks its grandchildren.
+  const child = spawn(command, { shell: true, cwd: cwd || process.cwd(), env: process.env, detached: true });
+  let buffer = '';
+  let stopped = false;
+  let code = null;
+  let nLines = 0;
+  // Settle-once guard shared by every completion path. The job's `done` MUST
+  // resolve: the session loop's streamJob guard — which swallows every key
+  // while a /run job is live — is only cleared by job.done settling. If
+  // 'close' never fires (a detached grandchild escaped the group kill and
+  // still holds the stdout pipe), 'exit' + the stop fallback cover it.
+  let doneResolved = false;
+  let resolveDone = null;
+
+  const deliver = (chunk) => {
+    buffer += chunk;
+    let idx;
+    while ((idx = buffer.indexOf('\n')) >= 0) {
+      const line = buffer.slice(0, idx).replace(/\r$/, '').trimEnd();
+      buffer = buffer.slice(idx + 1);
+      if (line && nLines++ < MAX_STREAM_LINES && onLine) onLine(line);
+    }
+  };
+  child.stdout && child.stdout.on('data', deliver);
+  child.stderr && child.stderr.on('data', deliver);
+  if (buffer.trim() && onLine) onLine(buffer.trim()); // trailing partial line
+
+  const killGroup = () => {
+    try { process.kill(-child.pid, 'SIGTERM'); } catch {}
+  };
+  const onAbort = () => { stopped = true; killGroup(); };
+  if (signal) signal.addEventListener('abort', onAbort, { once: true });
+
+  const settle = (patch) => {
+    if (doneResolved) return;
+    doneResolved = true;
+    if (signal) signal.removeEventListener('abort', onAbort);
+    resolveDone(patch);
+  };
+
+  const done = new Promise((resolve) => { resolveDone = resolve; });
+  child.on('error', () => settle({ code: code ?? 1, stopped }));
+  child.on('close', (c) => {
+    code = c;
+    settle({ code, stopped });
+  });
+  // 'close' waits for the stdio pipes; a grandchild that escaped the group
+  // keeps the write end open and 'close' never fires. Settle shortly after
+  // the shell itself exits, whatever the pipes do.
+  child.on('exit', () => setTimeout(() => settle({ code: code ?? 0, stopped }), 1000));
+
+  return {
+    stop: () => {
+      stopped = true;
+      killGroup();
+      // Pipe-holding survivors can still delay 'close' — force the job to
+      // settle so the session loop's streamJob guard can't swallow keys.
+      setTimeout(() => settle({ code: code ?? null, stopped: true }), 5000);
+    },
+    done,
+  };
+}
+
+module.exports = {
+  MAX_STREAM_LINES,
+  detectDevCommand,
+  runDevServer,
+};

package/src/engine.js

@@ -0,0 +1,62 @@
+'use strict';
+
+/**
+ * Wires the CLI into the same agent-loop engine the desktop app already
+ * ships (desktop/lib/local/engine.js, commit e4b0a9a): persistent-shell exec,
+ * readFile/writeFile/editFile/listDir/glob/grep, and Task subagents. This
+ * host only ever selects the 'aegis' class (it authenticates with an AEGIS
+ * key, not a local Ollama/BYOK endpoint), so the other three classes'
+ * dependencies (settings store, Ollama probe, custom-endpoint providers) are
+ * unreachable and stay stubs that throw if the engine ever calls them —
+ * proof that a code path meant only for those classes never silently runs
+ * here instead.
+ */
+
+const os = require('node:os');
+const { createLocalEngine } = require('./deps.js');
+const VERSION = require('../package.json').version;
+
+function unsupported(label) {
+  return async () => {
+    throw new Error(`aegiscode: ${label} is not available — this client only runs the aegis class`);
+  };
+}
+
+/**
+ * @param {object} client A client from client/aegis.js (createClient()).
+ * @param {() => boolean} getConfirmMode Whether mutating tools (exec,
+ *   writeFile, editFile) require approval before running. Read per call, so
+ *   toggling it (/permissions, /yolo) takes effect on the next tool round.
+ */
+function createEngine({ client, getConfirmMode }) {
+  const local = createLocalEngine({
+    aegis: client,
+    settings: { get: () => ({}), rawKey: unsupported('BYOK/custom endpoints') },
+    ollama: {
+      probe: async () => ({ running: false }),
+      listTags: async () => [],
+      chat: unsupported('Ollama'),
+    },
+    providers: {
+      anthropicMessages: unsupported('a custom Anthropic-compatible endpoint'),
+      openaiCompatible: unsupported('a custom OpenAI-compatible endpoint'),
+    },
+    env: {
+      platform: process.platform,
+      arch: process.arch,
+      homedir: os.homedir(),
+      cwd: process.cwd(),
+      appVersion: `aegiscode v${VERSION}`,
+    },
+    getConfirmMode,
+  });
+
+  return {
+    chat: (payload, onDelta) => local.chat({ ...payload, class: 'aegis' }, onDelta),
+    cancel: local.cancel,
+    respondApproval: local.respondApproval,
+    clearSessionApprovals: local.clearSessionApprovals,
+  };
+}
+
+module.exports = { createEngine };

package/src/events.js

@@ -0,0 +1,278 @@
+'use strict';
+
+/**
+ * The global key-event pump.
+ *
+ * A single stdin 'data' event may carry many keystrokes (pipes batch writes),
+ * so each chunk is split into characters and fed through a small state machine
+ * that also handles:
+ *
+ *   · a lone Escape, resolved by a short timeout so it is distinguishable from
+ *     the start of an escape sequence;
+ *   · bracketed paste (DECSET 2004) and, for terminals that ignore it, a
+ *     length/newline heuristic so a multi-line paste does not submit the prompt
+ *     line-by-line as it arrives;
+ *   · SGR mouse wheel events (DECSET 1000+1006), decoded to `{name:'wheel'}`
+ *     instead of being mistaken for Escape (which would abort a working turn).
+ *
+ * Ported from `aegiscodex-dev/src/events.js`. It is a module-level singleton —
+ * one stdin, one queue — which is what lets the session loop, a command
+ * handler's `askInput()`, and the mid-turn Esc drain all read keys through the
+ * same nextKey() without fighting over the `data` listener.
+ */
+
+const { decodeEscSequence, decodePlain, KEY } = require('./keys.js');
+
+const queue = [];
+let waiting = [];
+let buffer = '';
+let seq = '';
+let escTimer = null;
+
+// A paste-like chunk accumulates instead of being fed char-by-char; a short
+// idle window merges chunks that a pty fragmented across 'data' events.
+const PASTE_LARGE = 100;
+const PASTE_DEBOUNCE_MS = 30;
+let pasteChunks = [];
+let pasteTimer = null;
+
+const looksLikePaste = (s) => {
+  if (s.length > PASTE_LARGE) return true;
+  // A trailing \n or \r\n is the ordinary end of a piped batch, not evidence
+  // of a paste; strip one terminator before looking for an embedded newline.
+  return /[\n\r]/.test(s.replace(/\r\n$|[\r\n]$/, ''));
+};
+
+let attachedStdin = null;
+let onData = null;
+let suspended = false;
+
+function isKeyStreamSuspended() {
+  return suspended;
+}
+
+function attachKeyStream(stdin) {
+  attachedStdin = stdin;
+  onData = (chunk) => pushChars(String(chunk));
+  // A non-TTY stdin has no setRawMode at all; guard it so callers degrade
+  // instead of throwing "stdin.setRawMode is not a function".
+  if (typeof stdin.setRawMode === 'function') stdin.setRawMode(true);
+  stdin.resume();
+  stdin.setEncoding('utf8');
+  stdin.on('data', onData);
+}
+
+/** Hand the terminal to a child process: detach the pump and drop half-parsed
+ *  state so nothing leaks across the suspension. Pair with resumeKeyStream(). */
+function suspendKeyStream() {
+  if (!attachedStdin || suspended) return;
+  suspended = true;
+  attachedStdin.removeListener('data', onData);
+  clearTimeout(escTimer);
+  seq = '';
+  buffer = '';
+  clearTimeout(pasteTimer);
+  pasteTimer = null;
+  pasteChunks = [];
+  drainQueue();
+  try {
+    attachedStdin.setRawMode(false);
+  } catch {
+    /* not a TTY */
+  }
+  attachedStdin.pause();
+}
+
+function resumeKeyStream() {
+  if (!attachedStdin || !suspended) return;
+  suspended = false;
+  try {
+    attachedStdin.setRawMode(true);
+  } catch {
+    /* not a TTY */
+  }
+  attachedStdin.resume();
+  attachedStdin.setEncoding('utf8');
+  attachedStdin.on('data', onData);
+}
+
+function flushPaste() {
+  const raw = pasteChunks.join('');
+  pasteChunks = [];
+  pasteTimer = null;
+  // Strip any bracketed-paste framing that reached the buffer via a chunk
+  // split mid-frame, so literal [200~…[201~ can never leak into the editor.
+  const text = raw
+    .replace(/\x1b\[200~/g, '')
+    .replace(/\x1b\[201~/g, '')
+    .replace(/\r\n/g, '\n')
+    .replace(/\r/g, '\n')
+    .trimEnd();
+  if (text) dispatch({ name: 'paste', text });
+}
+
+function pushChars(s) {
+  const framed = s.match(/^\x1b\[200~(.*)\x1b\[201~$/s);
+  if (framed) {
+    pasteChunks.push(framed[1]);
+    clearTimeout(pasteTimer);
+    pasteTimer = setTimeout(flushPaste, PASTE_DEBOUNCE_MS);
+    return;
+  }
+  if (s.startsWith('\x1b[200~')) {
+    pasteChunks.push(s.slice('\x1b[200~'.length));
+    clearTimeout(pasteTimer);
+    pasteTimer = setTimeout(flushPaste, PASTE_DEBOUNCE_MS);
+    return;
+  }
+  if (pasteChunks.length || looksLikePaste(s)) {
+    pasteChunks.push(s);
+    clearTimeout(pasteTimer);
+    pasteTimer = setTimeout(flushPaste, PASTE_DEBOUNCE_MS);
+    return;
+  }
+  buffer += s;
+  while (buffer.length) {
+    const cp = buffer.codePointAt(0);
+    const c = String.fromCodePoint(cp);
+    const units = c.length;
+    if (units > buffer.length) break; // incomplete multi-byte char
+    buffer = buffer.slice(units);
+    feed(c);
+  }
+}
+
+function feed(c) {
+  if (c === '\x1b') {
+    clearTimeout(escTimer);
+    escTimer = setTimeout(() => {
+      // Nothing followed the ESC within the window → it was a bare Escape.
+      if (seq === '\x1b') dispatch({ name: KEY.ESC });
+      seq = '';
+    }, 60);
+    seq = '\x1b';
+    return;
+  }
+  if (seq === '\x1b') {
+    // First char after ESC: a CSI (ESC[), an SS3 (ESCO), or an Alt chord.
+    if (c === '[' || c === 'O') {
+      seq += c;
+      return;
+    }
+    clearTimeout(escTimer);
+    seq = '';
+    dispatch({ name: 'alt', ch: c });
+    return;
+  }
+  if (seq.startsWith('\x1b[') || seq.startsWith('\x1bO')) {
+    seq += c;
+    if (/[A-Za-z~]/.test(c)) {
+      clearTimeout(escTimer);
+      const mouseDir = parseSgrMouse(seq);
+      if (mouseDir) {
+        seq = '';
+        dispatch({ name: 'wheel', dir: mouseDir });
+        return;
+      }
+      const k = decodeEscSequence(seq);
+      seq = '';
+      if (k) dispatch(k);
+    }
+    return;
+  }
+  const key = decodePlain(c);
+  if (key) dispatch(key);
+}
+
+/**
+ * SGR mouse button code → wheel direction. 64 = up, 65 = down; modifier bits
+ * are masked off so Shift+wheel still scrolls. Anything else (clicks, drags)
+ * returns null, and the caller's CSI decoder ignores it — so stray mouse bytes
+ * can neither type into the editor nor abort a turn.
+ */
+function parseSgrMouse(seq) {
+  if (!seq.startsWith('\x1b[<')) return null;
+  const body = seq.slice(3).replace(/[Mm]$/, '');
+  const code = parseInt(body.split(';')[0], 10);
+  if (!Number.isFinite(code)) return null;
+  const base = code & ~0b111100;
+  if (base === 64) return 'up';
+  if (base === 65) return 'down';
+  return null;
+}
+
+function dispatch(key) {
+  if (waiting.length) {
+    const w = waiting.shift();
+    w(key);
+  } else {
+    queue.push(key);
+  }
+}
+
+/** The next key, waiting as long as it takes. */
+function nextKey() {
+  if (queue.length) return Promise.resolve(queue.shift());
+  return new Promise((resolve) => waiting.push(resolve));
+}
+
+/**
+ * nextKey with an upper bound: resolves null when no key arrives within `ms`.
+ * The session loop polls with this while a turn runs — it must never wedge on a
+ * key that never comes once the turn settles. The timeout path removes the
+ * resolver from the waiting stack, so a late keystroke routes to the queue and
+ * the loop's next nextKey() sees it.
+ */
+function nextKeyTimeout(ms) {
+  if (queue.length) return Promise.resolve(queue.shift());
+  return new Promise((resolve) => {
+    const timer = setTimeout(() => {
+      const i = waiting.indexOf(wrapper);
+      if (i !== -1) waiting.splice(i, 1);
+      resolve(null);
+    }, ms);
+    const wrapper = (key) => {
+      clearTimeout(timer);
+      resolve(key);
+    };
+    waiting.push(wrapper);
+  });
+}
+
+/** Put keys back at the FRONT of the queue (typed-ahead replay after a turn). */
+function requeueKeys(keys) {
+  if (keys && keys.length) queue.unshift(...keys);
+}
+
+function drainQueue() {
+  queue.length = 0;
+}
+
+/** Test seam: forget attached stdin, timers and queued keys. */
+function resetKeyStream() {
+  clearTimeout(escTimer);
+  clearTimeout(pasteTimer);
+  escTimer = null;
+  pasteTimer = null;
+  seq = '';
+  buffer = '';
+  pasteChunks = [];
+  drainQueue();
+  waiting = [];
+  attachedStdin = null;
+  onData = null;
+  suspended = false;
+}
+
+module.exports = {
+  KEY,
+  attachKeyStream,
+  suspendKeyStream,
+  resumeKeyStream,
+  isKeyStreamSuspended,
+  nextKey,
+  nextKeyTimeout,
+  requeueKeys,
+  drainQueue,
+  resetKeyStream,
+};