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

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,
+  };
+}

package/src/services/provider-settings.js

@@ -0,0 +1,226 @@
+import { getSetting, updateSettings } from '../config/settings.js';
+import {
+  BUILTIN_PROVIDERS,
+  MAX_EXTRA_PROVIDERS,
+  MAX_MODELS_PER_PROVIDER,
+  normalizeModelId,
+  normalizeProviderId,
+} from '../providers/catalog.js';
+
+/**
+ * Provider and model management for config.json.
+ *
+ * `/provider add|del` and `/addmodel|/delmodel` edit the same `extraProviders`
+ * list the file already uses, so a provider added at runtime is indistinguishable
+ * from one written by hand and survives restarts. Built-in providers are
+ * read-only: only their added model ids (in .ryuu/preferences.json) are editable.
+ */
+
+const BUILTIN_IDS = new Set(BUILTIN_PROVIDERS.map((provider) => provider.id));
+
+export function isBuiltinProviderId(id) {
+  return BUILTIN_IDS.has(String(id ?? '').trim().toLowerCase());
+}
+
+/** The stored extraProviders array, never the module-level default. */
+export function readExtraProviders(settings) {
+  const value = getSetting(settings, 'extraProviders');
+  return Array.isArray(value) ? value : [];
+}
+
+function modelIdsOf(entry) {
+  if (!Array.isArray(entry?.models)) return [];
+  return entry.models
+    .map((model) => normalizeModelId(typeof model === 'string' ? model : model?.id))
+    .filter(Boolean);
+}
+
+function normalizeBaseUrl(value) {
+  const text = String(value ?? '').trim();
+  if (!text) return null;
+  try {
+    const parsed = new URL(text);
+    if (!['http:', 'https:'].includes(parsed.protocol)) return null;
+    if (parsed.username || parsed.password) return null;
+    return parsed.toString().replace(/\/$/, '');
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * Add a user provider. The id comes from the name, so `/provider add river …`
+ * creates `river` and stores its key under `providers.river.apiKey`.
+ * Returns { ok, reason } with reason 'builtin' | 'exists' | 'invalid' |
+ * 'url' | 'limit' | 'write'.
+ */
+export async function addExtraProvider({ name, baseURL, apiKey = '', label = null }) {
+  const id = normalizeProviderId(name);
+  if (!id) return { ok: false, reason: 'invalid' };
+  if (BUILTIN_IDS.has(id)) return { ok: false, reason: 'builtin' };
+  const url = normalizeBaseUrl(baseURL);
+  if (!url) return { ok: false, reason: 'url' };
+  let reason = null;
+  let updated = false;
+  try {
+    await updateSettings((draft) => {
+      const entries = readExtraProviders(draft).filter((entry) => entry && typeof entry === 'object');
+      const existing = entries.find((entry) => normalizeProviderId(entry.id) === id);
+      if (existing) {
+        // Re-adding with a key is the documented way to update it.
+        if (!apiKey) {
+          reason = 'exists';
+          return draft;
+        }
+        draft.providers = draft.providers && typeof draft.providers === 'object' ? draft.providers : {};
+        const stored = draft.providers[id] && typeof draft.providers[id] === 'object' ? draft.providers[id] : {};
+        draft.providers[id] = { ...stored, apiKey: String(apiKey).trim() };
+        updated = true;
+        return draft;
+      }
+      if (entries.length >= MAX_EXTRA_PROVIDERS) {
+        reason = 'limit';
+        return draft;
+      }
+      entries.push({
+        id,
+        name: label || name,
+        baseURL: url,
+        models: [],
+        capabilities: { streaming: true, tools: true, reasoning: false, multimodal: false },
+      });
+      draft.extraProviders = entries;
+      if (apiKey) {
+        draft.providers = draft.providers && typeof draft.providers === 'object' ? draft.providers : {};
+        const stored = draft.providers[id] && typeof draft.providers[id] === 'object' ? draft.providers[id] : {};
+        draft.providers[id] = { ...stored, apiKey: String(apiKey).trim() };
+      } else if (draft.providers && typeof draft.providers === 'object' && !draft.providers[id]) {
+        draft.providers[id] = { apiKey: '' };
+      }
+      return draft;
+    });
+  } catch {
+    return { ok: false, reason: 'write' };
+  }
+  return reason ? { ok: false, reason } : { ok: true, reason: null, id, baseURL: url, updated };
+}
+
+/**
+ * Remove a user provider plus its credentials and remembered model.
+ * Returns { ok, reason } with reason 'builtin' | 'missing' | 'active' | 'write'.
+ */
+export async function removeExtraProvider(id, { active = false } = {}) {
+  const provider = normalizeProviderId(id);
+  if (!provider) return { ok: false, reason: 'missing' };
+  if (BUILTIN_IDS.has(provider)) return { ok: false, reason: 'builtin' };
+  if (active) return { ok: false, reason: 'active' };
+  let reason = null;
+  try {
+    await updateSettings((draft) => {
+      const entries = readExtraProviders(draft);
+      const index = entries.findIndex((entry) => normalizeProviderId(entry?.id) === provider);
+      if (index === -1) {
+        reason = 'missing';
+        return draft;
+      }
+      entries.splice(index, 1);
+      draft.extraProviders = entries;
+      if (draft.providers && typeof draft.providers === 'object') delete draft.providers[provider];
+      if (draft.providerModel && typeof draft.providerModel === 'object') delete draft.providerModel[provider];
+      return draft;
+    });
+  } catch {
+    return { ok: false, reason: 'write' };
+  }
+  return reason ? { ok: false, reason } : { ok: true, reason: null };
+}
+
+/**
+ * Append a model id to a user provider's `models`. The first model also becomes
+ * the provider's default. Returns { ok, reason, added, models } with reason
+ * 'missing' | 'builtin' | 'invalid' | 'exists' | 'limit' | 'write'.
+ */
+export async function addExtraProviderModel(id, model, { label = null } = {}) {
+  const provider = normalizeProviderId(id);
+  const modelId = normalizeModelId(model);
+  if (!provider) return { ok: false, reason: 'missing' };
+  if (!modelId) return { ok: false, reason: 'invalid' };
+  if (BUILTIN_IDS.has(provider)) return { ok: false, reason: 'builtin' };
+  let reason = null;
+  let models = [];
+  try {
+    await updateSettings((draft) => {
+      const entries = readExtraProviders(draft);
+      const entry = entries.find((item) => normalizeProviderId(item?.id) === provider);
+      if (!entry) {
+        reason = 'missing';
+        return draft;
+      }
+      models = modelIdsOf(entry);
+      if (models.includes(modelId)) {
+        reason = 'exists';
+        return draft;
+      }
+      if (models.length >= MAX_MODELS_PER_PROVIDER) {
+        reason = 'limit';
+        return draft;
+      }
+      models.push(modelId);
+      const storedNames = Array.isArray(entry.models)
+        ? new Map(entry.models.map((item) => [normalizeModelId(typeof item === 'string' ? item : item?.id), typeof item === 'object' ? item?.name : null]))
+        : new Map();
+      entry.models = models.map((item) => {
+        const display = storedNames.get(item);
+        return display && display !== item ? { id: item, name: display } : item;
+      });
+      if (!normalizeModelId(entry.defaultModel)) entry.defaultModel = modelId;
+      entry.name = entry.name || label || provider;
+      return draft;
+    });
+  } catch {
+    return { ok: false, reason: 'write' };
+  }
+  return reason ? { ok: false, reason, models } : { ok: true, reason: null, added: modelId, models };
+}
+
+/**
+ * Remove a model id from a user provider and recompute its default.
+ * Returns { ok, reason, models, defaultModel } with reason 'missing' | 'builtin'
+ * | 'invalid' | 'absent' | 'write'.
+ */
+export async function removeExtraProviderModel(id, model) {
+  const provider = normalizeProviderId(id);
+  const modelId = normalizeModelId(model);
+  if (!provider) return { ok: false, reason: 'missing' };
+  if (!modelId) return { ok: false, reason: 'invalid' };
+  if (BUILTIN_IDS.has(provider)) return { ok: false, reason: 'builtin' };
+  let reason = null;
+  let models = [];
+  let defaultModel = null;
+  try {
+    await updateSettings((draft) => {
+      const entries = readExtraProviders(draft);
+      const entry = entries.find((item) => normalizeProviderId(item?.id) === provider);
+      if (!entry) {
+        reason = 'missing';
+        return draft;
+      }
+      const current = modelIdsOf(entry);
+      if (!current.includes(modelId)) {
+        reason = 'absent';
+        models = current;
+        return draft;
+      }
+      models = current.filter((item) => item !== modelId);
+      entry.models = models;
+      if (normalizeModelId(entry.defaultModel) === modelId) entry.defaultModel = models[0] || null;
+      defaultModel = normalizeModelId(entry.defaultModel);
+      return draft;
+    });
+  } catch {
+    return { ok: false, reason: 'write' };
+  }
+  return reason
+    ? { ok: false, reason, models }
+    : { ok: true, reason: null, models, defaultModel };
+}