@otto-code/server 0.5.0

package/dist/server/server/agent/providers/diagnostic-utils.js

@@ -0,0 +1,355 @@
+import { constants } from "node:fs";
+import { access, stat } from "node:fs/promises";
+import path from "node:path";
+import { createProviderEnvSpec, } from "../provider-launch-config.js";
+import { execCommand } from "../../../utils/spawn.js";
+export function formatProviderDiagnostic(providerName, entries) {
+    return [providerName, ...entries.map((entry) => `  ${entry.label}: ${entry.value}`)].join("\n");
+}
+export function formatProviderDiagnosticError(providerName, error) {
+    return formatProviderDiagnostic(providerName, [
+        {
+            label: "Error",
+            value: toDiagnosticErrorMessage(error),
+        },
+    ]);
+}
+export function formatAvailabilityStatus(available) {
+    return available ? "Available" : "Unavailable";
+}
+export function formatDiagnosticStatus(available, error) {
+    if (error) {
+        return `Error (${error.source} failed: ${toDiagnosticErrorMessage(error.cause)})`;
+    }
+    return formatAvailabilityStatus(available);
+}
+const DIAGNOSTIC_OUTPUT_CAP = 4096;
+export function truncateForDiagnostic(value) {
+    const trimmed = value.trim();
+    if (trimmed.length <= DIAGNOSTIC_OUTPUT_CAP) {
+        return trimmed;
+    }
+    return `${trimmed.slice(0, DIAGNOSTIC_OUTPUT_CAP)}…(truncated)`;
+}
+function readStringProperty(error, key) {
+    if (!(key in error))
+        return undefined;
+    const value = error[key];
+    if (typeof value === "string") {
+        return value;
+    }
+    if (typeof value === "number" || typeof value === "bigint") {
+        return String(value);
+    }
+    return undefined;
+}
+function readUnknownProperty(error, key) {
+    if (!(key in error))
+        return undefined;
+    return error[key];
+}
+function pushIfNonEmpty(sections, label, value) {
+    if (value && value.trim().length > 0) {
+        sections.push(`${label}: ${value.trim()}`);
+    }
+}
+function pushTruncatedIfNonEmpty(sections, label, value) {
+    if (value && value.trim().length > 0) {
+        sections.push(`${label}: ${truncateForDiagnostic(value)}`);
+    }
+}
+function formatErrorDiagnostic(error) {
+    const sections = [];
+    if (error.message && error.message.trim().length > 0) {
+        sections.push(error.message.trim());
+    }
+    pushIfNonEmpty(sections, "exit code", readStringProperty(error, "code"));
+    pushIfNonEmpty(sections, "signal", readStringProperty(error, "signal"));
+    pushTruncatedIfNonEmpty(sections, "stderr", readStringProperty(error, "stderr"));
+    pushTruncatedIfNonEmpty(sections, "stdout", readStringProperty(error, "stdout"));
+    const cause = readUnknownProperty(error, "cause");
+    if (cause !== undefined && cause !== null) {
+        const causeMessage = toDiagnosticErrorMessage(cause);
+        if (causeMessage && causeMessage !== "Unknown error") {
+            sections.push(`caused by: ${causeMessage}`);
+        }
+    }
+    return sections.length > 0 ? sections.join("\n") : "Unknown error";
+}
+function formatNonErrorDiagnostic(error) {
+    try {
+        const serialized = JSON.stringify(error);
+        if (serialized && serialized !== "{}" && serialized !== '""') {
+            return serialized;
+        }
+    }
+    catch {
+        // fall through to String() below
+    }
+    const stringified = String(error);
+    if (stringified.length > 0 && stringified !== "[object Object]") {
+        return stringified;
+    }
+    return "Unknown error";
+}
+export function toDiagnosticErrorMessage(error) {
+    if (error instanceof Error) {
+        return formatErrorDiagnostic(error);
+    }
+    if (typeof error === "string") {
+        const trimmed = error.trim();
+        return trimmed.length > 0 ? trimmed : "Unknown error";
+    }
+    if (error === null || error === undefined) {
+        return "Unknown error";
+    }
+    return formatNonErrorDiagnostic(error);
+}
+export async function resolveBinaryVersion(binaryPath) {
+    try {
+        const { stdout } = await execCommand(binaryPath, ["--version"], {
+            ...createProviderEnvSpec(),
+            timeout: 5000,
+        });
+        return stdout.trim() || "unknown";
+    }
+    catch (error) {
+        return `error: ${toDiagnosticErrorMessage(error)}`;
+    }
+}
+const COMMAND_PROBE_TIMEOUT_MS = 3000;
+const COMMAND_PROBE_MAX_BUFFER = 32 * 1024;
+function resolvePlatform(options) {
+    return options?.platform ?? process.platform;
+}
+function resolvePathValue(options) {
+    return options?.pathValue ?? process.env["PATH"] ?? process.env["Path"] ?? "";
+}
+function resolveShellValue(options) {
+    if (options?.shell) {
+        return options.shell;
+    }
+    if (resolvePlatform(options) === "win32") {
+        return process.env["ComSpec"] ?? "cmd.exe";
+    }
+    return process.env["SHELL"] ?? "/bin/sh";
+}
+async function isExecutableFile(filePath, platform) {
+    try {
+        const candidate = await stat(filePath);
+        if (!candidate.isFile()) {
+            return false;
+        }
+        if (platform === "win32") {
+            return true;
+        }
+        await access(filePath, constants.X_OK);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+function resolveSearchableNames(binaryNames) {
+    return binaryNames.filter((binaryName) => binaryName.trim().length > 0 && !binaryName.includes("/") && !binaryName.includes("\\"));
+}
+function resolveWindowsPathExt(options) {
+    const value = options.pathext ?? process.env["PATHEXT"] ?? ".COM;.EXE;.BAT;.CMD";
+    return value
+        .split(";")
+        .map((extension) => extension.trim())
+        .filter(Boolean)
+        .map((extension) => (extension.startsWith(".") ? extension : `.${extension}`));
+}
+function resolveBinaryCandidateNames(binaryName, options) {
+    if (resolvePlatform(options) !== "win32" || path.win32.extname(binaryName)) {
+        return [binaryName];
+    }
+    return [binaryName, ...resolveWindowsPathExt(options).map((extension) => binaryName + extension)];
+}
+async function formatPathMatches(options) {
+    const binaryNames = options.knownBinaryNames;
+    const searchableNames = resolveSearchableNames(binaryNames);
+    if (searchableNames.length === 0) {
+        return "not checked";
+    }
+    const pathDelimiter = resolvePlatform(options) === "win32" ? ";" : path.delimiter;
+    const pathEntries = resolvePathValue(options).split(pathDelimiter).filter(Boolean);
+    const matches = [];
+    const seen = new Set();
+    const platform = resolvePlatform(options);
+    for (const directory of pathEntries) {
+        for (const binaryName of searchableNames) {
+            for (const candidateName of resolveBinaryCandidateNames(binaryName, options)) {
+                const candidate = path.join(directory, candidateName);
+                if (seen.has(candidate)) {
+                    continue;
+                }
+                seen.add(candidate);
+                if (await isExecutableFile(candidate, platform)) {
+                    matches.push(candidate);
+                }
+            }
+        }
+    }
+    return matches.length > 0 ? matches.join("\n    ") : "none";
+}
+function shellToken(value) {
+    return `'${value.replace(/'/g, "'\\''")}'`;
+}
+function formatCommandProbeOutput(stdout, stderr) {
+    const sections = [];
+    const trimmedStdout = truncateForDiagnostic(stdout);
+    const trimmedStderr = truncateForDiagnostic(stderr);
+    if (trimmedStdout.length > 0) {
+        sections.push(trimmedStdout);
+    }
+    if (trimmedStderr.length > 0) {
+        sections.push(`stderr: ${trimmedStderr}`);
+    }
+    return sections.length > 0 ? sections.join("\n") : "(no output)";
+}
+function formatCommandProbeError(error) {
+    return toDiagnosticErrorMessage(error);
+}
+async function runCommandProbe(command, args) {
+    try {
+        const { stdout, stderr } = await execCommand(command, args, {
+            timeout: COMMAND_PROBE_TIMEOUT_MS,
+            killSignal: "SIGKILL",
+            maxBuffer: COMMAND_PROBE_MAX_BUFFER,
+        });
+        return formatCommandProbeOutput(stdout, stderr);
+    }
+    catch (error) {
+        return formatCommandProbeError(error);
+    }
+}
+async function buildPosixCommandProbeRows(binaryName) {
+    const shell = resolveShellValue();
+    const typeCommand = `type -a ${shellToken(binaryName)}`;
+    return [
+        {
+            label: `which -a ${binaryName}`,
+            value: await runCommandProbe("/usr/bin/which", ["-a", binaryName]),
+        },
+        {
+            label: `${path.basename(shell)} -lc type -a ${binaryName}`,
+            value: await runCommandProbe(shell, ["-lc", typeCommand]),
+        },
+    ];
+}
+async function buildWindowsCommandProbeRows(binaryName) {
+    const powershellCommand = [
+        "$ErrorActionPreference = 'Continue';",
+        `Get-Command -All ${JSON.stringify(binaryName)} |`,
+        "Select-Object CommandType,Source,Name,Definition |",
+        "Format-List",
+    ].join(" ");
+    return [
+        {
+            label: `where.exe ${binaryName}`,
+            value: await runCommandProbe("where.exe", [binaryName]),
+        },
+        {
+            label: `powershell Get-Command -All ${binaryName}`,
+            value: await runCommandProbe("powershell.exe", [
+                "-NoProfile",
+                "-ExecutionPolicy",
+                "Bypass",
+                "-Command",
+                powershellCommand,
+            ]),
+        },
+    ];
+}
+async function buildCommandProbeRows(binaryNames) {
+    const searchableNames = resolveSearchableNames(binaryNames);
+    if (searchableNames.length === 0) {
+        return [];
+    }
+    const rows = [];
+    for (const binaryName of searchableNames) {
+        rows.push(...(process.platform === "win32"
+            ? await buildWindowsCommandProbeRows(binaryName)
+            : await buildPosixCommandProbeRows(binaryName)));
+    }
+    return rows;
+}
+export async function buildCommandResolutionDiagnosticRows(launch, options) {
+    const includeCommandProbes = options.includeCommandProbes ?? true;
+    return [
+        {
+            label: "Command source",
+            value: launch.source,
+        },
+        {
+            label: "Configured command",
+            value: [launch.command, ...launch.args].join(" "),
+        },
+        {
+            label: "Daemon PATH",
+            value: truncateForDiagnostic(resolvePathValue(options)) || "(empty)",
+        },
+        {
+            label: "Daemon shell",
+            value: resolveShellValue(options),
+        },
+        {
+            label: "PATH matches",
+            value: await formatPathMatches(options),
+        },
+        ...(includeCommandProbes ? await buildCommandProbeRows(options.knownBinaryNames) : []),
+    ];
+}
+async function resolveCommandVersion(invocation) {
+    try {
+        const { stdout, stderr } = await execCommand(invocation.command, invocation.args, {
+            ...createProviderEnvSpec({ runtimeSettings: { env: invocation.env } }),
+            timeout: 5000,
+        });
+        return stdout.trim() || stderr.trim() || "unknown";
+    }
+    catch (error) {
+        return `error: ${toDiagnosticErrorMessage(error)}`;
+    }
+}
+export async function buildBinaryDiagnosticRows(launch, availability, options = {}) {
+    const defaultBinaryLabel = launch.source === "override" ? "Binary (override)" : "Binary";
+    const binaryLabel = options.binaryLabel ?? defaultBinaryLabel;
+    let version = "unknown";
+    if (options.versionCommand && availability.available) {
+        version = await resolveCommandVersion(options.versionCommand);
+    }
+    else if (availability.available) {
+        version = await resolveCommandVersion({
+            command: availability.resolvedPath ?? launch.command,
+            args: [...launch.args, "--version"],
+        });
+    }
+    return [
+        {
+            label: binaryLabel,
+            value: launch.command,
+        },
+        {
+            label: "Resolved path",
+            value: availability.resolvedPath ?? "not found",
+        },
+        {
+            label: "Version",
+            value: version,
+        },
+    ];
+}
+export function formatConfiguredCommand(defaultArgv, runtimeSettings) {
+    const command = runtimeSettings?.command;
+    if (!command || command.mode === "default") {
+        return `${defaultArgv.join(" ")} (default)`;
+    }
+    if (command.mode === "append") {
+        return [defaultArgv[0], ...(command.args ?? []), ...defaultArgv.slice(1)].join(" ");
+    }
+    return command.argv.join(" ");
+}
+//# sourceMappingURL=diagnostic-utils.js.map

package/dist/server/server/agent/providers/generic-acp-agent.d.ts

@@ -0,0 +1,42 @@
+import type { Logger } from "pino";
+import { z } from "zod";
+import { ACPAgentClient, type ACPExtensionCommandsParser } from "./acp-agent.js";
+export declare const GenericACPProviderParamsSchema: z.ZodObject<{
+    supportsMcpServers: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$loose>;
+interface GenericACPAgentClientOptions {
+    logger: Logger;
+    command: [string, ...string[]];
+    env?: Record<string, string>;
+    providerId?: string;
+    label?: string;
+    providerParams?: unknown;
+    waitForInitialCommands?: boolean;
+    initialCommandsWaitTimeoutMs?: number;
+    diagnosticPhaseTimeoutMs?: number;
+    extensionCommandsParser?: ACPExtensionCommandsParser;
+}
+export declare class GenericACPAgentClient extends ACPAgentClient {
+    private readonly command;
+    private readonly providerId?;
+    private readonly label?;
+    private readonly diagnosticPhaseTimeoutMs?;
+    constructor(options: GenericACPAgentClientOptions);
+    protected resolveLaunchCommand(): Promise<{
+        command: string;
+        args: string[];
+    }>;
+    isAvailable(): Promise<boolean>;
+    getDiagnostic(): Promise<{
+        diagnostic: string;
+    }>;
+    private resolveConfiguredLaunch;
+    private getACPProbeRowsForDiagnostic;
+}
+export interface CommandInvocation {
+    command: string;
+    args: string[];
+}
+export declare function buildVersionProbeCommand(command: [string, ...string[]]): CommandInvocation;
+export {};
+//# sourceMappingURL=generic-acp-agent.d.ts.map

package/dist/server/server/agent/providers/generic-acp-agent.js

@@ -0,0 +1,160 @@
+import { z } from "zod";
+import { checkProviderLaunchAvailable, resolveProviderLaunch } from "../provider-launch-config.js";
+import { ACPAgentClient, DEFAULT_ACP_CAPABILITIES, } from "./acp-agent.js";
+import { buildBinaryDiagnosticRows, formatProviderDiagnostic, toDiagnosticErrorMessage, } from "./diagnostic-utils.js";
+export const GenericACPProviderParamsSchema = z
+    .object({
+    supportsMcpServers: z.boolean().optional(),
+})
+    .passthrough();
+export class GenericACPAgentClient extends ACPAgentClient {
+    constructor(options) {
+        super({
+            provider: "acp",
+            logger: options.logger,
+            runtimeSettings: {
+                env: options.env,
+            },
+            defaultCommand: options.command,
+            capabilities: buildGenericACPCapabilities(options),
+            waitForInitialCommands: options.waitForInitialCommands,
+            initialCommandsWaitTimeoutMs: options.initialCommandsWaitTimeoutMs,
+            extensionCommandsParser: options.extensionCommandsParser,
+        });
+        this.command = options.command;
+        this.providerId = options.providerId;
+        this.label = options.label;
+        this.diagnosticPhaseTimeoutMs = options.diagnosticPhaseTimeoutMs;
+    }
+    async resolveLaunchCommand() {
+        return {
+            command: this.command[0],
+            args: this.command.slice(1),
+        };
+    }
+    async isAvailable() {
+        const launch = await this.resolveConfiguredLaunch();
+        const availability = await checkProviderLaunchAvailable(launch);
+        return availability.available;
+    }
+    async getDiagnostic() {
+        const providerName = formatProviderName(this.label, this.providerId);
+        const entries = [
+            { label: "Provider ID", value: this.providerId ?? "unknown" },
+            { label: "Configured command", value: this.command.join(" ") },
+        ];
+        const versionProbe = buildVersionProbeCommand(this.command);
+        try {
+            const launch = await this.resolveConfiguredLaunch();
+            const availability = await checkProviderLaunchAvailable(launch);
+            entries.push(...(await buildBinaryDiagnosticRows(launch, availability, {
+                binaryLabel: "Launcher binary",
+                versionCommand: {
+                    command: versionProbe.command,
+                    args: versionProbe.args,
+                    env: this.runtimeSettings?.env,
+                },
+            })));
+        }
+        catch (error) {
+            entries.push({
+                label: "Launcher binary",
+                value: `error: ${toDiagnosticErrorMessage(error)}`,
+            });
+        }
+        entries.push({
+            label: "Version command",
+            value: formatCommand(versionProbe.command, versionProbe.args),
+        }, ...(await this.getACPProbeRowsForDiagnostic()));
+        return {
+            diagnostic: formatProviderDiagnostic(providerName, entries),
+        };
+    }
+    async resolveConfiguredLaunch() {
+        return resolveProviderLaunch({
+            commandConfig: { mode: "replace", argv: this.command },
+            defaultBinary: this.command[0],
+        });
+    }
+    async getACPProbeRowsForDiagnostic() {
+        try {
+            return await this.buildACPProbeDiagnosticRows({
+                phaseTimeoutMs: this.diagnosticPhaseTimeoutMs,
+            });
+        }
+        catch (error) {
+            return [
+                {
+                    label: "ACP probe",
+                    value: `error: ${toDiagnosticErrorMessage(error)}`,
+                },
+            ];
+        }
+    }
+}
+function buildGenericACPCapabilities(options) {
+    const params = parseGenericACPProviderParams(options.providerParams);
+    return {
+        ...DEFAULT_ACP_CAPABILITIES,
+        supportsMcpServers: params.supportsMcpServers ?? DEFAULT_ACP_CAPABILITIES.supportsMcpServers,
+    };
+}
+function parseGenericACPProviderParams(params) {
+    return GenericACPProviderParamsSchema.parse(params ?? {});
+}
+function formatProviderName(label, providerId) {
+    if (label) {
+        return `${label} (ACP)`;
+    }
+    if (providerId) {
+        return `${providerId} (ACP)`;
+    }
+    return "Custom ACP";
+}
+function formatCommand(command, args) {
+    return [command, ...args].join(" ");
+}
+export function buildVersionProbeCommand(command) {
+    const [launcher, ...args] = command;
+    if (isPackageRunner(launcher)) {
+        return {
+            command: launcher,
+            args: [...takePackageRunnerPrefix(args), "--version"],
+        };
+    }
+    return {
+        command: launcher,
+        args: ["--version"],
+    };
+}
+function isPackageRunner(command) {
+    return ["npx", "bunx", "pnpm", "uvx"].includes(command);
+}
+function takePackageRunnerPrefix(args) {
+    if (args.length === 0) {
+        return [];
+    }
+    if (args[0] === "dlx") {
+        return ["dlx", ...takePackageSpecPrefix(args.slice(1))];
+    }
+    return takePackageSpecPrefix(args);
+}
+function takePackageSpecPrefix(args) {
+    const prefix = [];
+    for (let index = 0; index < args.length; index += 1) {
+        const arg = args[index];
+        prefix.push(arg);
+        if (arg === "--package" || arg === "-p") {
+            if (args[index + 1]) {
+                prefix.push(args[index + 1]);
+                index += 1;
+            }
+            continue;
+        }
+        if (!arg.startsWith("-")) {
+            break;
+        }
+    }
+    return prefix;
+}
+//# sourceMappingURL=generic-acp-agent.js.map

package/dist/server/server/agent/providers/kiro-acp-agent.d.ts

@@ -0,0 +1,17 @@
+import type { Logger } from "pino";
+import type { ACPExtensionCommandsParser } from "./acp-agent.js";
+import { GenericACPAgentClient } from "./generic-acp-agent.js";
+interface KiroACPAgentClientOptions {
+    logger: Logger;
+    command: [string, ...string[]];
+    env?: Record<string, string>;
+    providerId?: string;
+    label?: string;
+    providerParams?: unknown;
+}
+export declare const parseKiroExtensionCommands: ACPExtensionCommandsParser;
+export declare class KiroACPAgentClient extends GenericACPAgentClient {
+    constructor(options: KiroACPAgentClientOptions);
+}
+export {};
+//# sourceMappingURL=kiro-acp-agent.d.ts.map

package/dist/server/server/agent/providers/kiro-acp-agent.js

@@ -0,0 +1,78 @@
+import { GenericACPAgentClient } from "./generic-acp-agent.js";
+// Kiro CLI publishes its slash commands and skills asynchronously through the
+// `_kiro.dev/commands/available` extension notification shortly after
+// `session/new` resolves. Wait for that first batch so listCommands() doesn't
+// resolve to an empty list before Kiro has reported its commands.
+const KIRO_INITIAL_COMMANDS_WAIT_TIMEOUT_MS = 10000;
+// ACP extension method (per the `_`-prefixed vendor namespace convention) that
+// Kiro CLI uses to publish its slash commands and skills after session/new.
+const KIRO_COMMANDS_AVAILABLE_METHOD = "_kiro.dev/commands/available";
+function isRecord(value) {
+    return value != null && typeof value === "object" && !Array.isArray(value);
+}
+// Maps a `_kiro.dev/commands/available` payload onto Otto slash commands.
+// Kiro reports built-in slash commands under `commands` (names arrive with a
+// leading "/", e.g. "/agent") and skills/prompts under `prompts` (names without
+// a slash, tagged with a `skill:` serverName). Otto stores command names
+// without the leading slash — the composer prepends it on insertion.
+function mapKiroAvailableCommands(params) {
+    const result = [];
+    const seen = new Set();
+    const pushEntry = (entry) => {
+        if (!isRecord(entry)) {
+            return;
+        }
+        const rawName = typeof entry.name === "string" ? entry.name.trim() : "";
+        const name = rawName.replace(/^\/+/, "");
+        if (!name || seen.has(name)) {
+            return;
+        }
+        seen.add(name);
+        const description = typeof entry.description === "string" ? entry.description : "";
+        const meta = isRecord(entry.meta) ? entry.meta : null;
+        const argumentHint = meta && typeof meta.hint === "string" ? meta.hint : "";
+        const serverName = typeof entry.serverName === "string" ? entry.serverName : "";
+        const kind = serverName.startsWith("skill:") ? "skill" : "command";
+        result.push({ name, description, argumentHint, kind });
+    };
+    if (Array.isArray(params.commands)) {
+        for (const entry of params.commands) {
+            pushEntry(entry);
+        }
+    }
+    if (Array.isArray(params.prompts)) {
+        for (const entry of params.prompts) {
+            pushEntry(entry);
+        }
+    }
+    return result;
+}
+// Provider-specific parser injected into the generic ACP session via the
+// `extensionCommandsParser` option (mirrors how Cursor/Copilot inject their
+// behavior through constructor options). Kiro advertises its slash commands and
+// skills through the `_kiro.dev/commands/available` extension notification
+// instead of the standard `available_commands_update` session update; this
+// recognizes that one method and returns the parsed commands (possibly empty),
+// or null for any other notification so the base session ignores it.
+export const parseKiroExtensionCommands = (method, params) => {
+    if (method !== KIRO_COMMANDS_AVAILABLE_METHOD) {
+        return null;
+    }
+    return mapKiroAvailableCommands(params);
+};
+export class KiroACPAgentClient extends GenericACPAgentClient {
+    constructor(options) {
+        super({
+            logger: options.logger,
+            command: options.command,
+            env: options.env,
+            providerId: options.providerId,
+            label: options.label,
+            providerParams: options.providerParams,
+            waitForInitialCommands: true,
+            initialCommandsWaitTimeoutMs: KIRO_INITIAL_COMMANDS_WAIT_TIMEOUT_MS,
+            extensionCommandsParser: parseKiroExtensionCommands,
+        });
+    }
+}
+//# sourceMappingURL=kiro-acp-agent.js.map