klyro 1.0.16 → 1.0.18

package/dist/eval/harness.js

@@ -122,7 +122,7 @@ export async function runTask(t, opts = {}) {
             try {
                 await fs.rm(cwd, { recursive: true, force: true });
             }
-            catch { }
+            catch { /* ignore — best-effort tmp cleanup */ }
         }
     }
 }
@@ -177,10 +177,46 @@ export async function loadFileFixture(dir) {
     catch { /* no script → static fixture */ }
     return { dir, task: task.trim(), checkSh, meta, ...(repo ? { repo } : {}), ...(script ? { script } : {}) };
 }
-export async function runFileFixture(fixture, opts = {}) {
+/**
+ * 5.4b — sanitized env for `check.sh`: PATH + home/locale + temp vars
+ * (+ Windows shell vars so the shell can spawn). Everything else —
+ * secrets, `KLYRO_*` config, caller sentinels — is dropped. Exported for tests.
+ */
+const FIXTURE_ENV_ALLOW = new Set([
+    'PATH', 'PATHEXT', 'HOME', 'LANG', 'LC_ALL', 'TMPDIR', 'TEMP', 'TMP',
+    'SYSTEMROOT', 'SYSTEMDRIVE', 'COMSPEC',
+]);
+export function sanitizedFixtureEnv(base = process.env) {
+    const out = {};
+    for (const k of FIXTURE_ENV_ALLOW) {
+        const v = base[k];
+        if (v !== undefined)
+            out[k] = v;
+    }
+    return out;
+}
+/**
+ * 5.4b — guard: fixture workdirs must stay inside `os.tmpdir()` (the
+ * harness relies on that isolation). Throws otherwise unless the caller
+ * explicitly passes `allowWorkdirOutsideTmp`. Exported for tests.
+ */
+export function assertTmpWorkdir(dir, opts = {}) {
+    if (opts.allowWorkdirOutsideTmp)
+        return;
+    const root = path.resolve(os.tmpdir());
+    const resolved = path.resolve(dir);
+    if (resolved !== root && !resolved.startsWith(root + path.sep)) {
+        throw new Error(`fixture workdir escapes os.tmpdir(): ${resolved} (pass allowWorkdirOutsideTmp to override)`);
+    }
+}
+export async function runFileFixture(fixture, _opts = {}) {
     const start = Date.now();
     const tmp = path.join(os.tmpdir(), 'klyro-eval-file-' + Math.random().toString(36).slice(2));
+    assertTmpWorkdir(tmp, _opts);
     await fs.mkdir(tmp, { recursive: true });
+    // Restrictive creation (umask-style): the tmp workdir is owner-only.
+    // Best-effort — chmod is a no-op for ACLs on Windows but harmless.
+    await fs.chmod(tmp, 0o700).catch(() => undefined);
     // Copy repo if exists
     if (fixture.repo) {
         const src = path.isAbsolute(fixture.repo) ? fixture.repo : path.join(fixture.dir, fixture.repo);
@@ -192,7 +228,7 @@ export async function runFileFixture(fixture, opts = {}) {
     // Run check.sh via shell
     const { spawn } = await import('node:child_process');
     const result = await new Promise((resolve) => {
-        const child = spawn('bash', ['-c', fixture.checkSh], { cwd: tmp, shell: false });
+        const child = spawn('bash', ['-c', fixture.checkSh], { cwd: tmp, shell: false, env: sanitizedFixtureEnv() });
         const sink = cappedOutput(MAX_CHECK_BYTES);
         child.stdout?.on('data', (b) => sink.push(b));
         child.stderr?.on('data', (b) => sink.push(b));
@@ -226,7 +262,9 @@ export async function runAgentFixture(fixture, opts = {}) {
         return { id, status: 'fail', details: 'agent fixture needs script.json', durationMs: Date.now() - start };
     }
     const tmp = path.join(os.tmpdir(), 'klyro-eval-agent-' + Math.random().toString(36).slice(2));
+    assertTmpWorkdir(tmp, opts);
     await fs.mkdir(tmp, { recursive: true });
+    await fs.chmod(tmp, 0o700).catch(() => undefined);
     try {
         if (fixture.repo) {
             const src = path.isAbsolute(fixture.repo) ? fixture.repo : path.join(fixture.dir, fixture.repo);
@@ -250,7 +288,7 @@ export async function runAgentFixture(fixture, opts = {}) {
         // Structural pass — now assert real filesystem outcomes.
         const { spawn } = await import('node:child_process');
         const out = await new Promise((resolve) => {
-            const child = spawn('bash', ['-c', fixture.checkSh], { cwd: tmp, shell: false });
+            const child = spawn('bash', ['-c', fixture.checkSh], { cwd: tmp, shell: false, env: sanitizedFixtureEnv() });
             const sink = cappedOutput(MAX_CHECK_BYTES);
             child.stdout?.on('data', (b) => sink.push(b));
             child.stderr?.on('data', (b) => sink.push(b));

package/dist/index.js

@@ -145,6 +145,27 @@ async function main() {
         const code = await runUpdate({ apply: !!opts.apply });
         process.exit(code);
     });
+    program
+        .command('version')
+        .description('Print the version number')
+        .action(() => {
+        process.stdout.write(`${VERSION}\n`);
+    });
+    program
+        .command('help [command]')
+        .description('Print help (same as --help)')
+        .action(async (cmd) => {
+        if (cmd) {
+            const target = program.commands.find((c) => c.name() === cmd);
+            if (!target) {
+                process.stderr.write(`klyro: unknown command: ${cmd}\n`);
+                process.exit(2);
+            }
+            target.outputHelp();
+            return;
+        }
+        program.outputHelp();
+    });
     program
         .command('login')
         .description('Login and store API key (masked, 0600) — provider auto-select')
@@ -191,7 +212,12 @@ async function main() {
         .command('doctor')
         .description('Run diagnostics (node, config, provider, sessions, git, tools)')
         .option('--json', 'Output JSON')
+        .option('--keys', 'Interactive key probe: show raw bytes your terminal sends (arrows, paste, wheel)')
         .action(async (opts) => {
+        if (opts.keys) {
+            const { runKeysProbe } = await import('./cli/doctor.js');
+            process.exit(await runKeysProbe());
+        }
         const code = await runDoctor({ json: !!opts.json });
         process.exit(code);
     });
@@ -297,8 +323,16 @@ async function main() {
         .description('Run a one-shot autonomous task. Streams text to stdout; tool calls to stderr.')
         .option('-m, --model <id>', 'Model id (default: env KLYRO_MODEL)')
         .option('--max-steps <n>', 'Max agent steps (default 30)', (v) => parsePositiveInt('--max-steps', v))
+        .option('--max-turns <n>', 'Alias for --max-steps (smaller wins when both are set)', (v) => parsePositiveInt('--max-turns', v))
         .option('--max-tokens <n>', 'Max output tokens per step', (v) => parsePositiveInt('--max-tokens', v))
         .option('--temperature <n>', 'Sampling temperature (0-2)', parseTemperature)
+        .option('--reasoning-effort <level>', 'Reasoning effort for reasoning models: low|medium|high')
+        .option('--system-prompt <text>', 'Replace the assembled system prompt wholesale')
+        .option('--append-system-prompt <text>', 'Extra instructions appended after the system prompt')
+        .option('--permission-mode <mode>', 'Policy mode: default|accept-edits|plan|auto')
+        .option('--allowed-tools <list>', 'Comma-separated tool names pre-approved for this run')
+        .option('--disallowed-tools <list>', 'Comma-separated tool names denied for this run (deny always wins)')
+        .option('--add-dir <path>', 'Extra sandbox directory (repeatable/comma-separated), like /add-dir')
         .option('--timeout <ms>', 'Request timeout in ms (default: env KLYRO_TIMEOUT_MS or 60000)', (v) => parsePositiveInt('--timeout', v))
         .option('--base-url <url>', 'Override KLYRO_BASE_URL')
         .option('--api-key <key>', 'Override KLYRO_API_KEY')
@@ -316,6 +350,7 @@ async function main() {
         .option('--agent <name>', 'Run under an orchestrator context enabling spawn_agent/task_list/task_get (explorer|implementer|tester|reviewer)')
         .option('--max-depth <n>', 'Max spawn depth for child agents (default 1)', (v) => parsePositiveInt('--max-depth', v))
         .option('--bare', 'Deterministic runs: skip MCP, hooks, memory/KLYRO.md/context, persistence')
+        .option('--auto-answer <text>', 'Headless answer for ask_user prompts (sets KLYRO_AUTO_ANSWER)')
         .action(async (prompt, opts) => {
         const model = opts.model ?? process.env.KLYRO_MODEL;
         if (!model) {
@@ -332,6 +367,16 @@ async function main() {
             process.stderr.write(`klyro: invalid --verify-mode: ${opts.verifyMode} (expected strict|advisory|off)\n`);
             process.exit(2);
         }
+        const reasoningEffort = opts.reasoningEffort;
+        if (reasoningEffort !== undefined && reasoningEffort !== 'low' && reasoningEffort !== 'medium' && reasoningEffort !== 'high') {
+            process.stderr.write(`klyro: invalid --reasoning-effort: ${opts.reasoningEffort} (expected low|medium|high)\n`);
+            process.exit(2);
+        }
+        const permissionMode = opts.permissionMode;
+        if (permissionMode !== undefined && permissionMode !== 'default' && permissionMode !== 'accept-edits' && permissionMode !== 'plan' && permissionMode !== 'auto') {
+            process.stderr.write(`klyro: invalid --permission-mode: ${opts.permissionMode} (expected default|accept-edits|plan|auto)\n`);
+            process.exit(2);
+        }
         // Provider validation is handled inside runOnce (single source of truth)
         try {
             const code = await runOnce({
@@ -339,8 +384,16 @@ async function main() {
                 cwd: process.cwd(),
                 model,
                 maxSteps: opts.maxSteps,
+                maxTurns: opts.maxTurns,
                 maxTokens: opts.maxTokens,
                 temperature: opts.temperature,
+                reasoningEffort,
+                systemPromptText: opts.systemPrompt,
+                appendSystemPrompt: opts.appendSystemPrompt,
+                permissionMode,
+                allowedTools: opts.allowedTools,
+                disallowedTools: opts.disallowedTools,
+                addDir: opts.addDir,
                 timeoutMs: opts.timeout,
                 baseUrl: opts.baseUrl,
                 apiKey: opts.apiKey,
@@ -358,6 +411,7 @@ async function main() {
                 agent: opts.agent,
                 maxDepth: opts.maxDepth,
                 bare: !!opts.bare,
+                autoAnswer: opts.autoAnswer,
             });
             process.exit(code);
         }
@@ -391,17 +445,18 @@ async function main() {
         .option('--model <id>', 'Model for eval')
         .option('--judge-model <id>', 'Live model id for grading judge.rubric (needs endpoint + key)')
         .option('--cwd <path>', 'Shared scenario workdir (default: isolated tmp per scenario)')
+        .option('--auto-answer <text>', 'Headless answer for ask_user prompts (sets KLYRO_AUTO_ANSWER)')
         .action(async (input, opts) => {
         const output = (opts.output ?? 'human');
         if (opts.suite) {
-            const code = await runEval({ inputPath: input ?? '-', output, suite: opts.suite, filter: opts.filter, runs: opts.runs, parallel: opts.parallel, model: opts.model, judgeModel: opts.judgeModel });
+            const code = await runEval({ inputPath: input ?? '-', output, suite: opts.suite, filter: opts.filter, runs: opts.runs, parallel: opts.parallel, model: opts.model, judgeModel: opts.judgeModel, cwd: opts.cwd, autoAnswer: opts.autoAnswer });
             process.exit(code);
         }
         if (!input) {
             process.stderr.write('klyro eval: missing input (provide <input> or --suite)\n');
             process.exit(2);
         }
-        const code = await runEval({ inputPath: input, output, suite: opts.suite, filter: opts.filter, runs: opts.runs, parallel: opts.parallel, model: opts.model, judgeModel: opts.judgeModel, cwd: opts.cwd });
+        const code = await runEval({ inputPath: input, output, suite: opts.suite, filter: opts.filter, runs: opts.runs, parallel: opts.parallel, model: opts.model, judgeModel: opts.judgeModel, cwd: opts.cwd, autoAnswer: opts.autoAnswer });
         process.exit(code);
     });
     program
@@ -729,7 +784,6 @@ async function main() {
 }
 main().catch((err) => {
     // Last-resort: anything that escaped the command handlers lands here.
-    // eslint-disable-next-line no-console
     console.error(`klyro: ${err instanceof Error ? err.message : String(err)}`);
     process.exit(1);
 });

package/dist/persistence/store.js

@@ -180,11 +180,11 @@ export class SessionStore {
                 try {
                     pIdx = JSON.parse(await fs.readFile(pp, 'utf-8'));
                 }
-                catch { }
+                catch { /* missing index — start fresh */ }
                 pIdx[id] = record;
                 await this.writePerProjectIndex(pp, pIdx);
             }
-            catch { }
+            catch { /* best-effort — the primary index above already persisted */ }
             return record;
         });
     }

package/dist/policy/approval.js

@@ -16,8 +16,11 @@ import { patternForCall } from './patterns.js';
  */
 export function sanitizeForPrompt(s) {
     const noAnsi = s
+        // eslint-disable-next-line no-control-regex -- intentional: stripping CSI + OSC sequences
         .replace(/\x1b\[[0-9;]*[A-Za-z]/g, '')
+        // eslint-disable-next-line no-control-regex -- intentional: stripping OSC sequences
         .replace(/\x1b\][^\x07]*\x07/g, '');
+    // eslint-disable-next-line no-control-regex -- intentional: stripping C0 controls
     const clean = noAnsi.replace(/[\x00-\x08\x0b-\x0d\x0e-\x1f\x7f]/g, '');
     const LIMIT = 500;
     if (clean.length > LIMIT) {

package/dist/policy/path-guard.d.ts

@@ -21,13 +21,18 @@ export declare class PathGuardError extends Error {
 /**
  * Resolve a (possibly relative) path against cwd and assert it stays inside.
  * Does NOT follow symlinks — call `resolveAndFollowSymlinks` for that.
+ * `extraRoots` (--add-dir / agent sandbox extensions, relative entries
+ * resolve against cwd) are tried in order when the path escapes cwd.
  */
-export declare function resolveWithinCwd(cwd: string, requested: string): PathGuardResult;
+export declare function resolveWithinCwd(cwd: string, requested: string, extraRoots?: readonly string[]): PathGuardResult;
 /**
- * Resolve, follow symlinks, and assert the target stays inside cwd.
- * Use this for read_file / write_file to defeat symlink-based escapes.
+ * Resolve, follow symlinks, and assert the target stays inside cwd (or one
+ * of `extraRoots`). Use this for read_file / write_file to defeat
+ * symlink-based escapes. Symlink checks run against the winning root, so a
+ * link inside an added dir pointing outside it is refused exactly like a
+ * cwd escape.
  */
-export declare function resolveAndFollowSymlinks(cwd: string, requested: string): Promise<PathGuardResult>;
+export declare function resolveAndFollowSymlinks(cwd: string, requested: string, extraRoots?: readonly string[]): Promise<PathGuardResult>;
 /**
  * Symlink-swap guard: refuse when the FINAL path itself is a symlink.
  *

package/dist/policy/path-guard.js

@@ -33,31 +33,55 @@ function normalizeForCompare(p) {
 /**
  * Resolve a (possibly relative) path against cwd and assert it stays inside.
  * Does NOT follow symlinks — call `resolveAndFollowSymlinks` for that.
+ * `extraRoots` (--add-dir / agent sandbox extensions, relative entries
+ * resolve against cwd) are tried in order when the path escapes cwd.
  */
-export function resolveWithinCwd(cwd, requested) {
+export function resolveWithinCwd(cwd, requested, extraRoots) {
+    return resolveWithinRoots(cwd, requested, extraRoots);
+}
+function tryContain(root, requested) {
+    const resolved = path.isAbsolute(requested) ? path.resolve(requested) : path.resolve(root, requested);
+    // Use relative to test containment. path.relative throws on different
+    // drives on Windows; normalize to handle that.
+    const rel = path.relative(root, resolved);
+    if (rel === '' || (!rel.startsWith('..') && !path.isAbsolute(rel)))
+        return { resolved };
+    // Different drive on Windows: relative starts with a drive letter
+    if (isWindows() && /^[A-Za-z]:[\\/]/.test(rel))
+        return { drive: true };
+    return null;
+}
+function resolveWithinRoots(cwd, requested, extraRoots) {
+    const roots = extraRoots ?? [];
     if (!requested || requested.length === 0) {
         throw new PathGuardError(TOOL_ERROR_CODES.INVALID_INPUT, 'Path is empty');
     }
     const absCwd = path.resolve(cwd);
-    const resolved = path.isAbsolute(requested) ? path.resolve(requested) : path.resolve(absCwd, requested);
-    // Use relative to test containment. path.relative throws on different
-    // drives on Windows; normalize to handle that.
-    const rel = path.relative(absCwd, resolved);
-    if (rel === '' || (!rel.startsWith('..') && !path.isAbsolute(rel))) {
-        return { resolved };
+    const first = tryContain(absCwd, requested);
+    if (first && !('drive' in first))
+        return { resolved: first.resolved, root: absCwd };
+    for (const extra of roots) {
+        const root = path.isAbsolute(extra) ? path.resolve(extra) : path.resolve(absCwd, extra);
+        if (root === absCwd)
+            continue;
+        const hit = tryContain(root, requested);
+        if (hit && !('drive' in hit))
+            return { resolved: hit.resolved, root };
     }
-    // Different drive on Windows: relative starts with a drive letter
-    if (isWindows() && /^[A-Za-z]:[\\/]/.test(rel)) {
+    if (first && 'drive' in first) {
         throw new PathGuardError(TOOL_ERROR_CODES.PATH_ESCAPE, `Path escapes cwd (different drive): ${requested}`);
     }
     throw new PathGuardError(TOOL_ERROR_CODES.PATH_ESCAPE, `Path escapes cwd: ${requested}`);
 }
 /**
- * Resolve, follow symlinks, and assert the target stays inside cwd.
- * Use this for read_file / write_file to defeat symlink-based escapes.
+ * Resolve, follow symlinks, and assert the target stays inside cwd (or one
+ * of `extraRoots`). Use this for read_file / write_file to defeat
+ * symlink-based escapes. Symlink checks run against the winning root, so a
+ * link inside an added dir pointing outside it is refused exactly like a
+ * cwd escape.
  */
-export async function resolveAndFollowSymlinks(cwd, requested) {
-    const { resolved } = resolveWithinCwd(cwd, requested);
+export async function resolveAndFollowSymlinks(cwd, requested, extraRoots) {
+    const { resolved, root } = resolveWithinRoots(cwd, requested, extraRoots);
     let real;
     let realParent;
     try {
@@ -77,21 +101,21 @@ export async function resolveAndFollowSymlinks(cwd, requested) {
             return { resolved };
         }
     }
-    const absCwd = await fs.realpath(cwd).catch(() => path.resolve(cwd));
+    const absRoot = await fs.realpath(root).catch(() => path.resolve(root));
     const cmpReal = normalizeForCompare(real);
-    const cmpCwd = normalizeForCompare(absCwd);
-    if (cmpReal !== cmpCwd && !cmpReal.startsWith(cmpCwd + path.sep)) {
+    const cmpRoot = normalizeForCompare(absRoot);
+    if (cmpReal !== cmpRoot && !cmpReal.startsWith(cmpRoot + path.sep)) {
         throw new PathGuardError(TOOL_ERROR_CODES.PATH_ESCAPE, `Symlink target escapes cwd: ${requested} -> ${real}`);
     }
     // Defense-in-depth: ensure the parent directory of the resolved target
-    // is also inside cwd. This catches the case where the requested path
-    // walks through a symlinked parent (e.g. `<cwd>/evil-link/../escape`)
-    // and `real` happens to land back inside cwd but the parent was outside.
-    // Skip when the target itself is cwd (realParent would be the parent of
-    // cwd, which is necessarily outside).
-    if (real !== absCwd) {
+    // is also inside the winning root. This catches the case where the
+    // requested path walks through a symlinked parent (e.g. `<root>/evil-link/../escape`)
+    // and `real` happens to land back inside the root but the parent was outside.
+    // Skip when the target itself is the root (realParent would be the parent of
+    // the root, which is necessarily outside).
+    if (real !== absRoot) {
         const cmpRealParent = normalizeForCompare(realParent);
-        if (cmpRealParent !== cmpCwd && !cmpRealParent.startsWith(cmpCwd + path.sep)) {
+        if (cmpRealParent !== cmpRoot && !cmpRealParent.startsWith(cmpRoot + path.sep)) {
             throw new PathGuardError(TOOL_ERROR_CODES.PATH_ESCAPE, `Path escapes cwd via parent symlink: ${requested} -> ${realParent}`);
         }
     }

package/dist/providers/endpoints.js

@@ -47,6 +47,14 @@ const BUILTINS = [
         defaultModel: 'local-model',
         probePath: '/models',
     },
+    {
+        id: 'openrouter',
+        label: 'OpenRouter',
+        kind: 'openai-compatible',
+        baseURL: 'https://openrouter.ai/api/v1',
+        defaultModel: 'openai/gpt-4o-mini',
+        apiKeyEnv: ['KLYRO_API_KEY', 'OPENROUTER_API_KEY'],
+    },
 ];
 const custom = new Map();
 function validateEndpoint(def) {

package/dist/providers/model-info.d.ts

@@ -15,6 +15,7 @@ export interface ModelInfo {
 }
 export declare const MODEL_REGISTRY: Record<string, ModelInfo>;
 export declare function getModelInfo(id: string): ModelInfo;
+export declare function resolveModelAlias(id: string): string;
 /**
  * Single-source per-1K-token rate table, derived from MODEL_REGISTRY so
  * prices live in exactly one place. Local/self-hosted entries are $0.

package/dist/providers/model-info.js

@@ -12,6 +12,25 @@ export const MODEL_REGISTRY = {
 export function getModelInfo(id) {
     return MODEL_REGISTRY[id] ?? { id, contextWindow: 100000, maxOutput: 4096, inputPricePer1k: 0, outputPricePer1k: 0, capabilities: { tools: true } };
 }
+/**
+ * CLI model aliases (2.2): short names resolving against the registry so
+ * they never point at retired generations. Exact registry hits and unknown
+ * ids pass through untouched (the provider reports those errors).
+ */
+const MODEL_ALIASES = {
+    sonnet: 'claude-3-5-sonnet-20240620',
+    // No opus generation is pinned in the registry; closest capable Claude.
+    opus: 'claude-3-5-sonnet-20240620',
+    haiku: 'claude-3-haiku-20240307',
+    gpt: 'gpt-4o-mini',
+    local: 'local-model',
+};
+export function resolveModelAlias(id) {
+    if (!id || MODEL_REGISTRY[id])
+        return id;
+    const hit = MODEL_ALIASES[id.toLowerCase()];
+    return hit ?? id;
+}
 /**
  * Single-source per-1K-token rate table, derived from MODEL_REGISTRY so
  * prices live in exactly one place. Local/self-hosted entries are $0.

package/dist/providers.js

@@ -13,6 +13,7 @@
  */
 import { assertSafeBaseURL, normalizeBaseURL } from './chat.js';
 import { localProbeEndpoints } from './providers/endpoints.js';
+import { resolveModelAlias } from './providers/model-info.js';
 /**
  * Local probe candidates, derived from the single provider registry
  * (`providers/endpoints.ts`) — adding a local server there automatically
@@ -49,7 +50,9 @@ export async function resolveProvider() {
     };
     const envBaseURL = process.env.KLYRO_BASE_URL;
     const envKey = process.env.KLYRO_API_KEY;
-    const envModel = process.env.KLYRO_MODEL;
+    // Model aliases (2.2: sonnet/opus/haiku/gpt/local) resolve against the
+    // registry here so every consumer gets canonical ids.
+    const envModel = process.env.KLYRO_MODEL ? resolveModelAlias(process.env.KLYRO_MODEL) : undefined;
     // Persisted config loads first: it carries the allowInsecure opt-in that
     // also governs env URLs, and supplies model/key fallbacks everywhere.
     let cfg = {};
@@ -61,7 +64,8 @@ export async function resolveProvider() {
     const allowInsecure = cfg.allowInsecure === true;
     const cfgBase = (cfg.baseUrl ?? cfg.baseURL);
     const cfgProvider = cfg.provider;
-    const cfgModel = (cfg.model ?? cfg['model.default']);
+    const cfgModelRaw = (cfg.model ?? cfg['model.default']);
+    const cfgModel = cfgModelRaw ? resolveModelAlias(cfgModelRaw) : undefined;
     const cfgKey = (cfg.apiKey ?? cfg.api_key);
     // An explicitly configured endpoint that fails policy is a hard error —
     // fail loud with the reason instead of silently guessing another endpoint

package/dist/renderers/terminal.d.ts

@@ -7,3 +7,10 @@ export declare class TerminalRenderer {
     handle(ev: KlyroEvent): void;
     renderMarkdown(text: string): void;
 }
+/**
+ * Drain-aware stdout write shared by legacy streaming paths (3.1: all
+ * human output flows through the terminal renderer module). Sanitizes
+ * first, then waits for drain. Returns false if stdout closed (e.g. piped
+ * to `head`) or the abort signal fires — callers must stop producing.
+ */
+export declare function writeStdoutDrained(chunk: string, signal?: AbortSignal): Promise<boolean>;

package/dist/renderers/terminal.js

@@ -40,3 +40,55 @@ export class TerminalRenderer {
         process.stdout.write(sanitizeTerminalText(out));
     }
 }
+/**
+ * Drain-aware stdout write shared by legacy streaming paths (3.1: all
+ * human output flows through the terminal renderer module). Sanitizes
+ * first, then waits for drain. Returns false if stdout closed (e.g. piped
+ * to `head`) or the abort signal fires — callers must stop producing.
+ */
+export async function writeStdoutDrained(chunk, signal) {
+    const clean = sanitizeTerminalText(chunk);
+    return new Promise((resolve) => {
+        if (signal?.aborted) {
+            resolve(false);
+            return;
+        }
+        if (!process.stdout.write(clean)) {
+            let settled = false;
+            const cleanup = () => {
+                process.stdout.off('drain', onDrain);
+                process.stdout.off('error', onError);
+                if (signal)
+                    signal.removeEventListener('abort', onAbort);
+            };
+            const onDrain = () => {
+                if (settled)
+                    return;
+                settled = true;
+                cleanup();
+                resolve(true);
+            };
+            const onError = () => {
+                if (settled)
+                    return;
+                settled = true;
+                cleanup();
+                resolve(false);
+            };
+            const onAbort = () => {
+                if (settled)
+                    return;
+                settled = true;
+                cleanup();
+                resolve(false);
+            };
+            process.stdout.once('drain', onDrain);
+            process.stdout.once('error', onError);
+            if (signal)
+                signal.addEventListener('abort', onAbort, { once: true });
+        }
+        else {
+            resolve(true);
+        }
+    });
+}

package/dist/repl.d.ts

@@ -17,6 +17,15 @@ export interface Turn {
     role: 'user' | 'assistant';
     content: string;
 }
+/**
+ * Trailing-backslash continuation for the legacy REPL (1.4): a line ending
+ * in an odd run of backslashes joins the next line (one backslash removed,
+ * newline kept); anything else completes the prompt. Exported for tests.
+ */
+export declare function splitContinuedLine(pending: string, line: string): {
+    pending: string;
+    complete?: string;
+};
 export declare function repl(system: string): Promise<void>;
 /** Drop oldest turns to stay under the size cap. Keep user/assistant pairs together. */
 export declare function trimHistory(history: Turn[]): void;

package/dist/repl.js

@@ -22,6 +22,17 @@ import { estimateTokens } from './context/tokenizer.js';
 const MAX_HISTORY_TURNS = 40;
 /** Approximate char budget for the user side of history. */
 const MAX_HISTORY_CHARS = 80_000;
+/**
+ * Trailing-backslash continuation for the legacy REPL (1.4): a line ending
+ * in an odd run of backslashes joins the next line (one backslash removed,
+ * newline kept); anything else completes the prompt. Exported for tests.
+ */
+export function splitContinuedLine(pending, line) {
+    const m = /\\+$/.exec(line);
+    if (m && m[0].length % 2 === 1)
+        return { pending: pending + line.slice(0, -1) + '\n' };
+    return { pending: '', complete: pending + line };
+}
 export async function repl(system) {
     const provider = await resolveProvider();
     if (!provider) {
@@ -33,7 +44,7 @@ export async function repl(system) {
         console.error('    ollama serve   # then KLYRO_BASE_URL=http://localhost:11434/v1 KLYRO_MODEL=llama3.2');
         exit(2);
     }
-    const { baseURL, apiKey, model, source } = provider;
+    const { baseURL, apiKey, model } = provider;
     // Legacy REPL — prefer `klyro tui`; history truncation is approximate.
     process.stderr.write('klyro: legacy REPL — prefer `klyro tui`; history truncation is approximate.\n');
     const history = [];
@@ -62,26 +73,34 @@ export async function repl(system) {
     });
     if (isTTY)
         console.log(`klyro REPL — type :quit to exit, :clear to reset history  ${providerHelp(provider)}`);
+    // Trailing-backslash continuation (1.4): a line ending in an odd run of
+    // backslashes joins the next line (one backslash removed, newline kept).
+    let continued = '';
     try {
         while (true) {
             // In TTY mode, readline handles the prompt and echoes the user's typing.
             // In non-TTY mode, we write the prompt ourselves.
+            const tag = continued ? '... ' : (isTTY ? '> ' : '');
             if (!isTTY)
-                process.stdout.write('> ');
+                process.stdout.write(tag);
             let line;
             try {
                 // Pass the prompt only when readline is in charge (TTY). In non-TTY
                 // mode the prompt is suppressed (output: undefined) so passing '' is
                 // equivalent and avoids doubling.
-                line = await rl.question(isTTY ? '> ' : '');
+                line = await rl.question(isTTY ? tag : '');
             }
-            catch (err) {
+            catch {
                 // EOF on stdin (Ctrl-D) or close — exit cleanly.
                 break;
             }
             if (!line)
                 break; // empty line on EOF
-            const prompt = line.trim();
+            const step = splitContinuedLine(continued, line);
+            continued = step.pending;
+            if (step.complete === undefined)
+                continue;
+            const prompt = step.complete.trim();
             if (!prompt)
                 continue;
             if (prompt === ':quit' || prompt === ':exit')

package/dist/shared/index.d.ts

@@ -1,4 +1,5 @@
 export * from './errors.js';
 export * from './types.js';
 export * from './sanitize.js';
+export * from './proxy.js';
 export * from './json.js';

package/dist/shared/index.js

@@ -1,4 +1,5 @@
 export * from './errors.js';
 export * from './types.js';
 export * from './sanitize.js';
+export * from './proxy.js';
 export * from './json.js';