@ryuu-reinzz/ryuu-cli 0.0.0-stage → 0.3.1

package/src/services/preferences.js

@@ -0,0 +1,249 @@
+import fsp from 'node:fs/promises';
+import path from 'node:path';
+import {
+  DEFAULT_PROVIDER_ID,
+  MODEL_ID_PATTERN,
+  MAX_MODEL_ID_LENGTH,
+  normalizeModelId,
+  normalizeProviderId,
+} from '../providers/catalog.js';
+
+/**
+ * User preferences that survive CLI restarts: the active provider, the active
+ * model, and the model ids added with `/addmodel`.
+ *
+ * The state lives in the workspace's `.ryuu` folder next to sessions, logs,
+ * undo and cache, so the choice follows the project the CLI is run from.
+ * Values are validated before being read back, so a hand-edited or corrupt
+ * file can never put an invalid provider/model id into the config.
+ *
+ * Shape (all keys optional):
+ *   {
+ *     "provider": "tokenharbor",
+ *     "model": "deepseek-v4.1-flash:free",
+ *     "providerModel": { "nvidia": "…", "tokenharbor": "…" },
+ *     "providerModels": { "nvidia": ["added-id"] },
+ *     "models": ["legacy ids, read as the active provider's list"]
+ *   }
+ */
+
+/** Upper bound on user-added models, so the list cannot grow without limit. */
+export const MAX_CUSTOM_MODELS = 100;
+export { MAX_MODEL_ID_LENGTH, MODEL_ID_PATTERN, normalizeModelId };
+
+/** Root of the local state folder for a workspace. */
+export function stateDirFor(workspace) {
+  return path.join(workspace || '.', '.ryuu');
+}
+
+export function preferencesFile(dir) {
+  return path.join(dir, 'preferences.json');
+}
+
+/** Read the whole preferences object; {} when absent or corrupt. Never throws. */
+export async function readPreferences(dir) {
+  try {
+    const data = JSON.parse(await fsp.readFile(preferencesFile(dir), 'utf8'));
+    return data && typeof data === 'object' && !Array.isArray(data) ? data : {};
+  } catch {
+    return {};
+  }
+}
+
+/**
+ * Merge a patch into preferences.json. Other keys are preserved, so adding or
+ * removing a model never forgets the selected model, and switching a model
+ * never forgets the added ones.
+ */
+async function writePreferences(dir, patch) {
+  try {
+    const payload = {
+      ...(await readPreferences(dir)),
+      ...patch,
+      updatedAt: new Date().toISOString(),
+    };
+    await fsp.mkdir(dir, { recursive: true });
+    await fsp.writeFile(preferencesFile(dir), `${JSON.stringify(payload, null, 2)}\n`, 'utf8');
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+function normalizeModelList(raw) {
+  if (!Array.isArray(raw)) return [];
+  const models = [];
+  for (const entry of raw) {
+    const model = normalizeModelId(entry);
+    if (model && !models.includes(model)) models.push(model);
+    if (models.length >= MAX_CUSTOM_MODELS) break;
+  }
+  return models;
+}
+
+/** A validated `provider -> [model ids]` map (unknown entries skipped). */
+function modelListMap(raw) {
+  const map = {};
+  if (!raw || typeof raw !== 'object' || Array.isArray(raw)) return map;
+  for (const [id, list] of Object.entries(raw)) {
+    const providerId = normalizeProviderId(id);
+    if (providerId) map[providerId] = normalizeModelList(list);
+  }
+  return map;
+}
+
+/** A validated `provider -> model id` map. */
+function modelChoiceMap(raw) {
+  const map = {};
+  if (!raw || typeof raw !== 'object' || Array.isArray(raw)) return map;
+  for (const [id, model] of Object.entries(raw)) {
+    const providerId = normalizeProviderId(id);
+    const normalized = normalizeModelId(model);
+    if (providerId && normalized) map[providerId] = normalized;
+  }
+  return map;
+}
+
+/** Read the persisted model, or null when absent/invalid. Never throws. */
+export async function readModelPreference(dir) {
+  return normalizeModelId((await readPreferences(dir)).model);
+}
+
+/**
+ * Persist the model choice. With a provider id the choice is also recorded for
+ * that provider, so switching providers remembers each one's last model.
+ * Returns false (no throw) for invalid ids.
+ */
+export async function writeModelPreference(dir, model, { providerId = null } = {}) {
+  const id = normalizeModelId(model);
+  if (!id) return false;
+  const provider = normalizeProviderId(providerId);
+  if (!provider) return writePreferences(dir, { model: id });
+  const prefs = await readPreferences(dir);
+  return writePreferences(dir, {
+    model: id,
+    providerModel: { ...modelChoiceMap(prefs.providerModel), [provider]: id },
+  });
+}
+
+/** Last model chosen for a provider (falls back to the legacy top-level value). */
+export async function readProviderModel(dir, providerId) {
+  const provider = normalizeProviderId(providerId);
+  if (!provider) return null;
+  const prefs = await readPreferences(dir);
+  const choices = modelChoiceMap(prefs.providerModel);
+  if (choices[provider]) return choices[provider];
+  const hasChoices = Object.keys(choices).length > 0;
+  // Backwards compatibility: files written before per-provider models existed
+  // stored one top-level `model` for the then-active provider.
+  if (!hasChoices) {
+    const active = normalizeProviderId(prefs.provider) || DEFAULT_PROVIDER_ID;
+    if (provider === active) return normalizeModelId(prefs.model);
+  }
+  return null;
+}
+
+/** Persist a model choice for one provider without changing the active model. */
+export async function writeProviderModel(dir, providerId, model) {
+  const provider = normalizeProviderId(providerId);
+  const id = normalizeModelId(model);
+  if (!provider || !id) return false;
+  const prefs = await readPreferences(dir);
+  return writePreferences(dir, {
+    providerModel: { ...modelChoiceMap(prefs.providerModel), [provider]: id },
+  });
+}
+
+/** Read the persisted provider id, or null when absent/invalid. Never throws. */
+export async function readProviderPreference(dir) {
+  return normalizeProviderId((await readPreferences(dir)).provider);
+}
+
+/** Persist the active provider id. Returns false (no throw) for invalid ids. */
+export async function writeProviderPreference(dir, providerId) {
+  const id = normalizeProviderId(providerId);
+  if (!id) return false;
+  return writePreferences(dir, { provider: id });
+}
+
+/**
+ * The ids added with `/addmodel` for one provider, in insertion order,
+ * de-duplicated and validated. A corrupt entry is skipped instead of failing
+ * the whole list. Without a provider id the legacy shared list is returned.
+ */
+export async function readCustomModels(dir, providerId = null) {
+  const prefs = await readPreferences(dir);
+  const legacy = normalizeModelList(prefs.models);
+  const provider = normalizeProviderId(providerId);
+  if (!provider) return legacy;
+  const map = modelListMap(prefs.providerModels);
+  if (Array.isArray(map[provider])) return map[provider];
+  const active = normalizeProviderId(prefs.provider) || DEFAULT_PROVIDER_ID;
+  return provider === active ? legacy : [];
+}
+
+async function writeCustomModels(dir, providerId, models) {
+  const provider = normalizeProviderId(providerId);
+  if (!provider) return writePreferences(dir, { models });
+  const prefs = await readPreferences(dir);
+  return writePreferences(dir, {
+    providerModels: { ...modelListMap(prefs.providerModels), [provider]: models },
+  });
+}
+
+/**
+ * Add an id to a provider's saved model list. Returns { ok, reason, models };
+ * reason is 'invalid' | 'exists' | 'limit' | 'write' when ok is false.
+ */
+export async function addCustomModel(dir, id, providerId = null) {
+  const models = await readCustomModels(dir, providerId);
+  const model = normalizeModelId(id);
+  if (!model) return { ok: false, reason: 'invalid', models };
+  if (models.includes(model)) return { ok: false, reason: 'exists', models };
+  if (models.length >= MAX_CUSTOM_MODELS) return { ok: false, reason: 'limit', models };
+  const next = [...models, model];
+  const saved = await writeCustomModels(dir, providerId, next);
+  return saved ? { ok: true, reason: null, models: next } : { ok: false, reason: 'write', models };
+}
+
+/**
+ * Remove an id from a provider's saved model list. Returns { ok, reason,
+ * models }; reason is 'missing' | 'write' when ok is false.
+ */
+export async function removeCustomModel(dir, id, providerId = null) {
+  const models = await readCustomModels(dir, providerId);
+  const model = normalizeModelId(id);
+  if (!model || !models.includes(model)) return { ok: false, reason: 'missing', models };
+  const next = models.filter((entry) => entry !== model);
+  const saved = await writeCustomModels(dir, providerId, next);
+  return saved ? { ok: true, reason: null, models: next } : { ok: false, reason: 'write', models };
+}
+
+/**
+ * Apply the persisted `/provider` choice at startup. An explicit flag or a
+ * `provider` key in config.json wins and is never overwritten. Returns true when raw.provider
+ * was changed.
+ */
+export async function applyPersistedProvider(raw, { flagProvider = null, stateDir = null } = {}) {
+  if (flagProvider || raw.provider || !stateDir) return false;
+  const persisted = await readProviderPreference(stateDir);
+  if (!persisted) return false;
+  raw.provider = persisted;
+  return true;
+}
+
+/**
+ * Apply the persisted model at startup.
+ * Precedence: explicit --model flag (this run only) > persisted choice for the
+ * selected provider > the provider's own model variable > catalog default.
+ * Returns true when raw.model was changed.
+ */
+export async function applyPersistedModel(raw, { flagModel = null, stateDir = null, providerId = null } = {}) {
+  if (flagModel || !stateDir) return false;
+  const persisted = providerId
+    ? await readProviderModel(stateDir, providerId)
+    : await readModelPreference(stateDir);
+  if (!persisted || persisted === raw.model) return false;
+  raw.model = persisted;
+  return true;
+}

package/src/services/processes.js

@@ -0,0 +1,345 @@
+import { spawn } from 'node:child_process';
+import { EventEmitter } from 'node:events';
+import { StringDecoder } from 'node:string_decoder';
+import fs from 'node:fs';
+import path from 'node:path';
+import { ProcessError } from '../utils/errors.js';
+import { redact } from '../utils/redaction.js';
+
+const SECRET_ENV_PATTERN = /(API_KEY|ACCESS_TOKEN|SECRET|PASSWORD|PASSWD|PRIVATE_KEY|GITHUB_TOKEN|GH_TOKEN|NVIDIA_API_KEY)/i;
+const POSIX = process.platform !== 'win32';
+
+/** Running child processes, used by the last-resort exit cleanup. */
+const ACTIVE = new Set();
+let exitHookInstalled = false;
+
+function installExitHook() {
+  if (exitHookInstalled) return;
+  exitHookInstalled = true;
+  process.once('exit', () => {
+    for (const record of ACTIVE) {
+      try {
+        if (POSIX && record.pid) process.kill(-record.pid, 'SIGKILL');
+        else if (record.pid) process.kill(record.pid, 'SIGKILL');
+      } catch {
+        // Already gone.
+      }
+    }
+  });
+}
+
+/** Strip credential-looking variables from a child environment. */
+export function buildChildEnv(base = process.env, { allow = [], extra = {} } = {}) {
+  const allowSet = new Set(allow);
+  const env = {};
+  for (const [key, value] of Object.entries(base)) {
+    if (value === undefined) continue;
+    if (SECRET_ENV_PATTERN.test(key) && !allowSet.has(key)) continue;
+    env[key] = value;
+  }
+  env.RYUU_AGENT = '1';
+  return { ...env, ...extra };
+}
+
+function appendBounded(state, chunk, limit) {
+  const combined = state.text + chunk;
+  if (combined.length <= limit) {
+    state.text = combined;
+    return;
+  }
+  state.truncated = true;
+  const head = Math.max(0, Math.floor(limit * 0.4));
+  const tail = Math.max(0, limit - head);
+  state.text = `${combined.slice(0, head)}\n…[output truncated]…\n${combined.slice(combined.length - tail)}`;
+}
+
+/**
+ * Session-scoped process manager. Commands use spawn with an argument array
+ * and shell:false by default; shell syntax requires an explicit, separately
+ * approved tool path. Shell execution is not a sandbox.
+ */
+export class ProcessManager extends EventEmitter {
+  constructor({ workspace, logger = null, maxBufferBytes = 65536, defaultTimeoutMs = 120000, maxProcesses = 8, logDir = null } = {}) {
+    super();
+    if (!workspace) throw new ProcessError('ProcessManager requires a workspace.');
+    this.workspace = workspace;
+    this.logger = logger;
+    this.maxBufferBytes = maxBufferBytes;
+    this.defaultTimeoutMs = defaultTimeoutMs;
+    this.maxProcesses = maxProcesses;
+    this.logDir = logDir;
+    this.records = new Map();
+    this.completed = [];
+    this.counter = 0;
+    installExitHook();
+  }
+
+  #nextId() {
+    this.counter += 1;
+    return `p${this.counter}`;
+  }
+
+  #runningCount() {
+    return [...this.records.values()].filter((record) => record.status === 'running').length;
+  }
+
+  /**
+   * @param {object} options
+   * @param {string[]} [options.argv] argument array (preferred, shell:false)
+   * @param {string} [options.shellCommand] raw shell string (requires allowShell)
+   * @param {string} [options.cwd] workspace-relative working directory
+   * @param {number} [options.timeoutMs] 0 disables the timeout
+   * @param {string} [options.label]
+   */
+  start({ argv, shellCommand = null, cwd = '.', timeoutMs, label, env = {}, allowShell = false } = {}) {
+    if (this.#runningCount() >= this.maxProcesses) {
+      throw new ProcessError(`Too many running processes (limit ${this.maxProcesses}). Stop one with stop_process.`);
+    }
+
+    const useShell = Boolean(shellCommand);
+    if (useShell && !allowShell) {
+      throw new ProcessError('Shell execution is disabled. Set agent.allowShell=true in config.json to permit an approved shell command.');
+    }
+    let command;
+    let args;
+    if (useShell) {
+      command = shellCommand;
+      args = [];
+    } else {
+      if (!Array.isArray(argv) || argv.length === 0) {
+        throw new ProcessError('argv must be a non-empty array of strings, e.g. ["npm", "test"].');
+      }
+      if (argv.length > 200) throw new ProcessError('Too many arguments (max 200).');
+      for (const part of argv) {
+        if (typeof part !== 'string' || part.length === 0) throw new ProcessError('Every argv entry must be a non-empty string.');
+        if (part.includes('\0')) throw new ProcessError('Arguments must not contain NUL bytes.');
+        if (part.length > 20000) throw new ProcessError('Argument is too long (max 20000 chars).');
+      }
+      [command, ...args] = argv;
+    }
+
+    const resolvedCwd = this.workspace.resolve(cwd || '.');
+    let stat;
+    try {
+      stat = fs.statSync(resolvedCwd.absPath);
+    } catch {
+      throw new ProcessError(`Working directory not found: ${resolvedCwd.relPath}`);
+    }
+    if (!stat.isDirectory()) throw new ProcessError(`Working directory is not a directory: ${resolvedCwd.relPath}`);
+
+    const id = this.#nextId();
+    const startedAt = Date.now();
+    const record = {
+      id,
+      pid: null,
+      label: label || (useShell ? command : argv.join(' ')).slice(0, 120),
+      argv: useShell ? [command] : argv,
+      shellCommand: useShell ? command : null,
+      cwd: resolvedCwd.relPath,
+      status: 'running',
+      startedAt,
+      startedAtIso: new Date(startedAt).toISOString(),
+      endedAt: null,
+      durationMs: null,
+      exitCode: null,
+      signal: null,
+      timedOut: false,
+      stopRequested: false,
+      error: null,
+      truncated: false,
+      stdout: { text: '', truncated: false },
+      stderr: { text: '', truncated: false },
+    };
+    record.done = new Promise((resolveDone) => {
+      record.resolveDone = resolveDone;
+    });
+    this.records.set(id, record);
+
+    const child = spawn(command, args, {
+      cwd: resolvedCwd.absPath,
+      shell: useShell,
+      detached: POSIX,
+      stdio: ['ignore', 'pipe', 'pipe'],
+      env: buildChildEnv(process.env, { extra: env }),
+      windowsHide: true,
+    });
+    record.pid = child.pid ?? null;
+    record.child = child;
+    if (POSIX && child.pid) ACTIVE.add(record);
+
+    const outDecoder = new StringDecoder('utf8');
+    const errDecoder = new StringDecoder('utf8');
+    child.stdout?.on('data', (chunk) => {
+      const text = outDecoder.write(chunk);
+      appendBounded(record.stdout, text, this.maxBufferBytes);
+      record.truncated = record.truncated || record.stdout.truncated;
+      this.emit('output', { id, stream: 'stdout', text, record });
+    });
+    child.stderr?.on('data', (chunk) => {
+      const text = errDecoder.write(chunk);
+      appendBounded(record.stderr, text, this.maxBufferBytes);
+      record.truncated = record.truncated || record.stderr.truncated;
+      this.emit('output', { id, stream: 'stderr', text, record });
+    });
+
+    let timeoutTimer = null;
+    const effectiveTimeout = timeoutMs === undefined ? this.defaultTimeoutMs : timeoutMs;
+    if (effectiveTimeout > 0) {
+      timeoutTimer = setTimeout(() => {
+        if (record.status !== 'running') return;
+        record.timedOut = true;
+        this.logger?.warn('process timeout, terminating', { id, timeoutMs: effectiveTimeout });
+        this.#kill(record, 'SIGTERM');
+        const force = setTimeout(() => this.#kill(record, 'SIGKILL'), 2000);
+        force.unref();
+      }, effectiveTimeout);
+      timeoutTimer.unref?.();
+    }
+
+    const finalize = (exitCode, signal, spawnError = null) => {
+      if (record.status !== 'running') return;
+      if (timeoutTimer) clearTimeout(timeoutTimer);
+      if (outDecoder.end) appendBounded(record.stdout, outDecoder.end() || '', this.maxBufferBytes);
+      if (errDecoder.end) appendBounded(record.stderr, errDecoder.end() || '', this.maxBufferBytes);
+      const endedAt = Date.now();
+      record.endedAt = endedAt;
+      record.endedAtIso = new Date(endedAt).toISOString();
+      record.durationMs = endedAt - startedAt;
+      record.exitCode = exitCode;
+      record.signal = signal;
+      record.error = spawnError ? spawnError.message : null;
+      if (spawnError) record.status = 'failed';
+      else if (record.timedOut) record.status = 'timeout';
+      else if (record.stopRequested) record.status = 'killed';
+      else record.status = exitCode === 0 ? 'exited' : 'failed';
+      delete record.child;
+      ACTIVE.delete(record);
+      this.completed.unshift(record);
+      if (this.completed.length > 100) this.completed.pop();
+      this.emit('exit', { record });
+      this.#persist(record);
+      record.resolveDone(record);
+    };
+
+    child.on('error', (error) => {
+      finalize(null, null, error);
+    });
+    child.on('close', (code, signal) => {
+      finalize(code, signal);
+    });
+
+    this.emit('started', { record });
+    this.logger?.info('process started', { id, pid: record.pid, argv: record.argv, cwd: record.cwd, shell: useShell });
+    return record;
+  }
+
+  #kill(record, signal) {
+    if (!record.pid || record.status !== 'running') return;
+    try {
+      if (POSIX) process.kill(-record.pid, signal);
+      else process.kill(record.pid, signal);
+    } catch (error) {
+      if (error.code !== 'ESRCH') this.logger?.warn('failed to signal process', { id: record.id, signal, error: error.message });
+    }
+  }
+
+  /** Stop a process: graceful SIGTERM, then SIGKILL after graceMs. */
+  async stop(id, { graceMs = 3000, signal = 'SIGTERM' } = {}) {
+    const record = this.records.get(id);
+    if (!record) throw new ProcessError(`Unknown process id: ${id}`, { id });
+    if (record.status !== 'running') return { id, stopped: false, status: record.status, exitCode: record.exitCode };
+    record.stopRequested = true;
+    this.#kill(record, signal);
+    const killed = await Promise.race([
+      record.done.then(() => true),
+      new Promise((resolve) => setTimeout(() => resolve(false), graceMs)),
+    ]);
+    if (!killed) {
+      this.#kill(record, 'SIGKILL');
+      await Promise.race([record.done, new Promise((resolve) => setTimeout(resolve, 1000))]);
+    }
+    return { id, stopped: true, status: record.status, exitCode: record.exitCode, signal: record.signal, durationMs: record.durationMs };
+  }
+
+  async stopAll({ graceMs = 2000 } = {}) {
+    const running = [...this.records.values()].filter((record) => record.status === 'running');
+    await Promise.allSettled(running.map((record) => this.stop(record.id, { graceMs })));
+    return running.length;
+  }
+
+  get(id) {
+    const record = this.records.get(id) || this.completed.find((item) => item.id === id);
+    if (!record) throw new ProcessError(`Unknown process id: ${id}`, { id });
+    return record;
+  }
+
+  getOutput(id, { stream = 'both', tailBytes = 8000 } = {}) {
+    const record = this.get(id);
+    const tail = (state) => {
+      if (state.text.length <= tailBytes) return state.text;
+      return `…[showing last ${tailBytes} chars]…\n${state.text.slice(state.text.length - tailBytes)}`;
+    };
+    const result = { id: record.id, status: record.status, exitCode: record.exitCode, signal: record.signal, durationMs: record.durationMs };
+    if (stream === 'stdout' || stream === 'both') result.stdout = tail(record.stdout);
+    if (stream === 'stderr' || stream === 'both') result.stderr = tail(record.stderr);
+    result.truncated = record.stdout.truncated || record.stderr.truncated;
+    return result;
+  }
+
+  list({ includeCompleted = true } = {}) {
+    const running = [...this.records.values()].filter((record) => record.status === 'running');
+    const rows = running.map(summarize);
+    if (includeCompleted) rows.push(...this.completed.slice(0, 20).map(summarize));
+    return rows;
+  }
+
+  #persist(record) {
+    if (!this.logDir) return;
+    try {
+      fs.mkdirSync(this.logDir, { recursive: true, mode: 0o700 });
+      const payload = {
+        id: record.id,
+        label: record.label,
+        argv: record.argv,
+        cwd: record.cwd,
+        status: record.status,
+        exitCode: record.exitCode,
+        signal: record.signal,
+        startedAt: record.startedAtIso,
+        endedAt: record.endedAtIso,
+        durationMs: record.durationMs,
+        truncated: record.truncated,
+        stdout: redact(record.stdout.text),
+        stderr: redact(record.stderr.text),
+      };
+      fs.writeFileSync(path.join(this.logDir, `process-${record.id}.log`), `${JSON.stringify(payload, null, 2)}\n`, {
+        mode: 0o600,
+      });
+    } catch {
+      // Persistence failures must not break execution.
+    }
+  }
+
+  /** All records with metadata, used for final summaries. */
+  history() {
+    return [...this.completed].reverse().map(summarize);
+  }
+}
+
+function summarize(record) {
+  return {
+    id: record.id,
+    pid: record.pid,
+    label: record.label,
+    argv: record.argv,
+    cwd: record.cwd,
+    status: record.status,
+    exitCode: record.exitCode,
+    signal: record.signal,
+    startedAt: record.startedAtIso,
+    endedAt: record.endedAtIso,
+    durationMs: record.durationMs,
+    timedOut: record.timedOut,
+    truncated: record.truncated,
+  };
+}