@kruntime/komputer 0.1.1 → 0.1.3

package/dist/agent-session.js

@@ -2646,6 +2646,9 @@ export class AgentSession {
             throw new Error(`command not found: ${name}`);
         if (command.agent && command.agent !== this.agentName)
             throw new Error(`command ${name} belongs to agent ${command.agent}`);
+        if (isCommandHelpInput(input)) {
+            return { type: 'stdout', text: `${commandHelpText(name, command)}\n`, code: 0 };
+        }
         const by = normalizeBy(options.by || (typeof input.by === 'string' ? input.by : undefined));
         const toolName = `command:${name}`;
         const before = await this.runHook('tool.before', { tool: toolName, command: name, input, by });
@@ -2662,7 +2665,16 @@ export class AgentSession {
             throw new Error(authority.reason);
         }
         const toolUseId = id('tool');
-        const ctx = this.runtime.runtimeContext(this, { kind: 'command', name, input: currentInput, args: currentInput });
+        const parsed = parseCommandInput(name, command, currentInput);
+        const ctx = this.runtime.runtimeContext(this, {
+            kind: 'command',
+            name,
+            input: currentInput,
+            args: parsed.args,
+            argv: parsed.argv,
+            stdin: parsed.stdin,
+            env: parsed.env,
+        });
         await this.emit({ type: 'tool', status: 'requested', tool: toolName, input: currentInput, opId: toolUseId });
         await this.trace('tool.started', { name, input: currentInput, by, toolUseId });
         let result;
@@ -2677,20 +2689,30 @@ export class AgentSession {
             result = invocationMode ? await this.withTemporaryMode(invocationMode, runShell) : await runShell();
         }
         else if (command.kind === 'markdown') {
-            const args = Object.keys(currentInput).length ? `\n\nInput:\n${JSON.stringify(currentInput, null, 2)}` : '';
+            const prompt = String(command.prompt ?? '');
+            const rendered = renderMarkdownCommandPrompt(prompt, parsed.args, parsed.stdin);
+            const args = hasCommandTemplate(prompt) || Object.keys(currentInput).length === 0
+                ? ''
+                : `\n\nInput:\n${JSON.stringify(currentInput, null, 2)}`;
             const invocationMode = command.readonly === true
                 ? 'readonly'
                 : typeof command.mode === 'string'
                     ? command.mode
                     : undefined;
-            const runMarkdown = () => this.run(`${String(command.prompt ?? '')}${args}`, { by: options.by || `command:${name}`, model: typeof command.model === 'string' ? command.model : undefined });
+            const runMarkdown = () => this.run(`${rendered}${args}`, { by: options.by || `command:${name}`, model: typeof command.model === 'string' ? command.model : undefined });
             result = invocationMode ? await this.withTemporaryMode(invocationMode, runMarkdown) : await runMarkdown();
         }
         else {
-            if (!command.handler)
-                throw new Error(`command has no handler: ${name}`);
-            const handler = command.handler;
-            result = await this.withFsActor(options.by ? by : `command:${name}`, () => Promise.resolve(handler(ctx, currentInput)));
+            const main = command.main ?? command.handler;
+            if (!main)
+                throw new Error(`command has no main: ${name}`);
+            const runModule = () => this.withFsActor(options.by ? by : `command:${name}`, () => Promise.resolve(main(ctx, parsed.args)));
+            const invocationMode = command.readonly === true
+                ? 'readonly'
+                : typeof command.mode === 'string'
+                    ? command.mode
+                    : undefined;
+            result = invocationMode ? await this.withTemporaryMode(invocationMode, runModule) : await runModule();
         }
         const after = await this.runHook('tool.after', { tool: toolName, command: name, input: currentInput, result, by });
         if (after.rejected) {
@@ -2992,6 +3014,169 @@ function commandErrorText(command, error) {
 function isHelpArg(value) {
     return value === '--help' || value === '-h';
 }
+function isCommandHelpInput(input) {
+    const argv = stringArrayField(input, 'argv') || [];
+    return argv.length === 1 && isHelpArg(argv[0]);
+}
+function parseCommandInput(name, command, input) {
+    const argv = stringArrayField(input, 'argv') || [];
+    const stdin = typeof input.stdin === 'string' ? input.stdin : '';
+    const envRecord = recordField(input, 'env');
+    const env = envRecord ? stringRecord(envRecord) : undefined;
+    if (command.args === 'none') {
+        const extra = argv.filter((arg) => arg !== '--');
+        if (extra.length)
+            throw new Error(`${name}: unexpected argument: ${extra[0]}`);
+        return { argv, stdin, env, args: {} };
+    }
+    if (!command.args || command.args === 'argv')
+        return { argv, stdin, env, args: input };
+    return { argv, stdin, env, args: parseStructuredCommandArgs(name, command.args, input, argv) };
+}
+function parseStructuredCommandArgs(name, specs, input, argv) {
+    const parsed = {};
+    const options = commandOptionSpecs(specs);
+    for (const [key, spec] of Object.entries(specs)) {
+        if ('defaultValue' in spec)
+            parsed[key] = spec.defaultValue;
+        else if ('default' in spec && typeof spec.default !== 'function')
+            parsed[key] = spec.default;
+    }
+    for (const [key, value] of Object.entries(input)) {
+        if (key !== 'argv' && key !== 'stdin' && key !== 'env' && specs[key])
+            parsed[key] = value;
+    }
+    const positional = Object.entries(specs)
+        .filter(([, spec]) => typeof spec.position === 'number')
+        .sort((a, b) => Number(a[1].position) - Number(b[1].position));
+    let positionalIndex = 0;
+    for (let index = 0; index < argv.length; index += 1) {
+        const token = argv[index];
+        if (token === '--') {
+            for (const rest of argv.slice(index + 1))
+                assignPositional(name, parsed, positional, positionalIndex++, rest);
+            break;
+        }
+        if (token.startsWith('--')) {
+            const body = token.slice(2);
+            const eq = body.indexOf('=');
+            const option = eq >= 0 ? body.slice(0, eq) : body;
+            const resolved = options.get(option);
+            if (!resolved)
+                throw new Error(`${name}: unsupported option: --${option}`);
+            const [key, spec] = resolved;
+            if (spec.type === 'boolean' && eq < 0) {
+                parsed[key] = true;
+                continue;
+            }
+            const value = eq >= 0 ? body.slice(eq + 1) : argv[++index];
+            if (value === undefined)
+                throw new Error(`${name}: option requires an argument: --${key}`);
+            assignCommandArg(name, parsed, key, spec, value);
+            continue;
+        }
+        const eq = token.indexOf('=');
+        if (eq > 0 && specs[token.slice(0, eq)]) {
+            const key = token.slice(0, eq);
+            assignCommandArg(name, parsed, key, specs[key], token.slice(eq + 1));
+            continue;
+        }
+        assignPositional(name, parsed, positional, positionalIndex++, token);
+    }
+    for (const [key, spec] of Object.entries(specs)) {
+        if (spec.required === true && (parsed[key] === undefined || parsed[key] === '')) {
+            throw new Error(`${name}: missing required argument: --${key}`);
+        }
+        if (parsed[key] !== undefined)
+            parsed[key] = coerceCommandArg(name, key, spec, parsed[key]);
+    }
+    return parsed;
+}
+function commandOptionSpecs(specs) {
+    const options = new Map();
+    for (const [key, spec] of Object.entries(specs)) {
+        options.set(key, [key, spec]);
+        const flag = typeof spec.flag === 'string' ? normalizeCommandFlag(spec.flag) : undefined;
+        if (flag)
+            options.set(flag, [key, spec]);
+    }
+    return options;
+}
+function normalizeCommandFlag(flag) {
+    return flag.trim().replace(/^-+/, '');
+}
+function assignPositional(name, parsed, positional, index, value) {
+    const entry = positional[index];
+    if (!entry)
+        throw new Error(`${name}: unexpected argument: ${String(value)}`);
+    assignCommandArg(name, parsed, entry[0], entry[1], value);
+}
+function assignCommandArg(name, parsed, key, spec, value) {
+    const coerced = coerceCommandArg(name, key, spec, value);
+    if (spec.repeat) {
+        const current = Array.isArray(parsed[key]) ? parsed[key] : parsed[key] === undefined ? [] : [parsed[key]];
+        current.push(coerced);
+        parsed[key] = current;
+        return;
+    }
+    parsed[key] = coerced;
+}
+function coerceCommandArg(name, key, spec, value) {
+    if (value === undefined)
+        return value;
+    if (spec.type === 'string' || spec.type === 'path')
+        return String(value);
+    if (spec.type === 'number') {
+        const number = typeof value === 'number' ? value : Number(String(value));
+        if (!Number.isFinite(number))
+            throw new Error(`${name}: invalid value for --${key}: expected number`);
+        return number;
+    }
+    if (spec.type === 'boolean') {
+        if (typeof value === 'boolean')
+            return value;
+        const text = String(value).toLowerCase();
+        if (text === 'true' || text === '1' || text === 'yes')
+            return true;
+        if (text === 'false' || text === '0' || text === 'no')
+            return false;
+        throw new Error(`${name}: invalid value for --${key}: expected boolean`);
+    }
+    if (spec.type === 'json') {
+        if (typeof value !== 'string')
+            return value;
+        try {
+            return JSON.parse(value);
+        }
+        catch {
+            throw new Error(`${name}: invalid value for --${key}: expected json`);
+        }
+    }
+    return value;
+}
+function stringRecord(record) {
+    const output = {};
+    for (const [key, value] of Object.entries(record)) {
+        if (typeof value === 'string')
+            output[key] = value;
+    }
+    return output;
+}
+function hasCommandTemplate(prompt) {
+    return /\{\{\s*(?:arg|args)\.[A-Za-z0-9_.-]+\s*\}\}|\{\{\s*stdin\s*\}\}/.test(prompt);
+}
+function renderMarkdownCommandPrompt(prompt, args, stdin) {
+    return prompt.replace(/\{\{\s*((?:arg|args)\.([A-Za-z0-9_.-]+)|stdin)\s*\}\}/g, (_match, token, argName) => {
+        if (token === 'stdin')
+            return stdin;
+        const value = argName ? args[argName] : undefined;
+        if (value === undefined || value === null)
+            return '';
+        if (typeof value === 'string')
+            return value;
+        return JSON.stringify(value);
+    });
+}
 function isExpiredWorker(worker) {
     const expiresAt = typeof worker.expiresAt === 'string' ? Date.parse(worker.expiresAt) : Number.NaN;
     return Number.isFinite(expiresAt) && expiresAt <= Date.now();