open-multi-agent-kit 0.78.0

package/dist/commands/agent.js

@@ -0,0 +1,263 @@
+import { readdir, readFile, writeFile } from "fs/promises";
+import YAML from "yaml";
+import { getOmkPath, pathExists } from "../util/fs.js";
+import { style, header, status, label, bullet } from "../util/theme.js";
+const STABLE_AGENTS = new Set([
+    "aggregator",
+    "architect",
+    "coder",
+    "explorer",
+    "integrator",
+    "interviewer",
+    "ontology",
+    "planner",
+    "qa",
+    "researcher",
+    "reviewer",
+    "router",
+    "security",
+    "tester",
+    "vision-debugger",
+]);
+const CAPABILITY_FLAGS = ["OMK_MCP_ENABLED", "OMK_SKILLS_ENABLED", "OMK_HOOKS_ENABLED"];
+async function loadAgentMeta(id) {
+    const filePath = getOmkPath(`agents/roles/${id}.yaml`);
+    if (!(await pathExists(filePath)))
+        return null;
+    const content = await readFile(filePath, "utf-8");
+    const doc = YAML.parse(content);
+    const agent = (doc?.agent ?? {});
+    const promptArgs = agent.system_prompt_args ?? {};
+    return {
+        id,
+        name: agent.name ?? id,
+        role: promptArgs.OMK_ROLE ?? id,
+        extend: agent.extend,
+        description: agent.description ?? agent.prompt?.replace(/\s+/g, " ").slice(0, 200),
+        excludeTools: agent.exclude_tools,
+        filePath,
+        stable: STABLE_AGENTS.has(id),
+        mcpServers: parseTopFromHint(promptArgs.OMK_MCP_HINTS),
+        skills: parseTopFromHint(promptArgs.OMK_SKILL_HINTS),
+        hooks: parseTopFromHint(promptArgs.OMK_HOOK_HINTS),
+    };
+}
+async function listAllAgents() {
+    const rolesDir = getOmkPath("agents/roles");
+    if (!(await pathExists(rolesDir)))
+        return [];
+    const entries = await readdir(rolesDir);
+    const yamlFiles = entries
+        .filter((f) => f.endsWith(".yaml"))
+        .map((f) => f.replace(/\.yaml$/, ""));
+    const agents = await Promise.all(yamlFiles.map(loadAgentMeta));
+    return agents.filter((a) => a !== null).sort((a, b) => {
+        if (a.stable === b.stable)
+            return a.id.localeCompare(b.id);
+        return a.stable ? -1 : 1;
+    });
+}
+// ─── Commands ───
+export async function agentListCommand() {
+    const agents = await listAllAgents();
+    if (agents.length === 0) {
+        console.log(status.warn("No agents found. Run omk init to scaffold agents."));
+        return;
+    }
+    const stable = agents.filter((a) => a.stable);
+    const experimental = agents.filter((a) => !a.stable);
+    console.log(header("Agent Registry"));
+    console.log(label("Total", String(agents.length)));
+    console.log("");
+    console.log(style.purpleBold("🟢 Stable Agents") + style.gray(" — recommended for production"));
+    for (const a of stable) {
+        console.log(`  ${style.mintBold(a.id.padEnd(14))} ${style.gray(a.name)}`);
+    }
+    console.log("");
+    if (experimental.length > 0) {
+        console.log(style.orangeBold("🟡 Experimental Agents") + style.gray(" — use with caution"));
+        for (const a of experimental) {
+            console.log(`  ${style.cream(a.id.padEnd(14))} ${style.gray(a.name)}`);
+        }
+        console.log("");
+    }
+    console.log(style.gray("  Tip: omk agent show <name> for details"));
+}
+export async function agentShowCommand(id) {
+    const meta = await loadAgentMeta(id);
+    if (!meta) {
+        console.warn(status.warn(`Agent "${id}" not found.`));
+        console.warn(style.gray(`  Run "omk agent list" to see available agents.`));
+        return;
+    }
+    console.log(header(`Agent: ${meta.id}`));
+    console.log(label("Name", meta.name));
+    console.log(label("Role", meta.role));
+    console.log(label("Stability", meta.stable ? style.mint("stable") : style.orange("experimental")));
+    console.log(label("File", meta.filePath));
+    if (meta.extend) {
+        console.log(label("Extends", meta.extend));
+    }
+    if (meta.excludeTools && meta.excludeTools.length > 0) {
+        console.log(label("Excluded tools", String(meta.excludeTools.length)));
+        for (const tool of meta.excludeTools) {
+            console.log(bullet(style.gray(tool)));
+        }
+    }
+    console.log(label("MCP Servers", meta.mcpServers?.join(", ") ?? style.gray("default")));
+    console.log(label("Skills", meta.skills?.join(", ") ?? style.gray("default")));
+    console.log(label("Hooks", meta.hooks?.join(", ") ?? style.gray("default")));
+    if (meta.description) {
+        console.log("");
+        console.log(style.gray(meta.description));
+    }
+}
+export async function agentCreateCommand(name, options) {
+    const templateId = options.from ?? "coder";
+    const templatePath = getOmkPath(`agents/roles/${templateId}.yaml`);
+    const destPath = getOmkPath(`agents/roles/${name}.yaml`);
+    if (await pathExists(destPath)) {
+        console.warn(status.warn(`Agent "${name}" already exists.`));
+        console.warn(style.gray(`  ${destPath}`));
+        return;
+    }
+    if (!(await pathExists(templatePath))) {
+        console.warn(status.warn(`Template "${templateId}" not found.`));
+        console.warn(style.gray(`  Run "omk agent list" to see available agents.`));
+        return;
+    }
+    const templateContent = await readFile(templatePath, "utf-8");
+    const doc = YAML.parse(templateContent);
+    const agent = (doc?.agent ?? {});
+    const newDoc = {
+        version: doc.version ?? 1,
+        agent: {
+            ...agent,
+            name: `omk-${name}`,
+            system_prompt_args: {
+                ...agent.system_prompt_args,
+                OMK_ROLE: name,
+                OMK_MCP_ENABLED: "true",
+                OMK_SKILLS_ENABLED: "true",
+                OMK_HOOKS_ENABLED: "true",
+            },
+        },
+    };
+    await writeFile(destPath, YAML.stringify(newDoc));
+    console.log(status.success(`Agent "${name}" created from template "${templateId}".`));
+    console.log(style.gray(`  ${destPath}`));
+}
+export async function agentDoctorCommand() {
+    const agents = await listAllAgents();
+    const issues = [];
+    const agentsById = new Map(agents.map((agent) => [agent.id, agent]));
+    const okabePath = getOmkPath("agents/okabe.yaml");
+    const rootPath = getOmkPath("agents/root.yaml");
+    let okabeHealthy = false;
+    if (!(await pathExists(okabePath))) {
+        issues.push("Missing Okabe base agent: .omk/agents/okabe.yaml");
+    }
+    else {
+        const okabeContent = await readFile(okabePath, "utf-8");
+        const okabeDoc = YAML.parse(okabeContent);
+        const okabeAgent = (okabeDoc?.agent ?? {});
+        const okabeTools = Array.isArray(okabeAgent.tools) ? okabeAgent.tools.map(String) : [];
+        okabeHealthy =
+            okabeTools.some((tool) => tool.includes("kimi_cli.tools.agent:Agent")) &&
+                okabeTools.some((tool) => tool.includes("kimi_cli.tools.dmail:SendDMail"));
+        if (!okabeHealthy) {
+            issues.push("okabe: missing required Agent/SendDMail tools");
+        }
+        for (const issue of missingCapabilityFlagIssues("okabe", okabeAgent)) {
+            issues.push(issue);
+        }
+        // Note: hints are injected at runtime by scoped-agent-file.ts; skip for base agent
+    }
+    if (!(await pathExists(rootPath))) {
+        issues.push("Missing root agent: .omk/agents/root.yaml");
+    }
+    else {
+        const rootContent = await readFile(rootPath, "utf-8");
+        const rootDoc = YAML.parse(rootContent);
+        const rootAgent = (rootDoc?.agent ?? {});
+        if (String(rootAgent.extend ?? "") !== "./okabe.yaml") {
+            issues.push("root: expected extend: ./okabe.yaml");
+        }
+        for (const issue of missingCapabilityFlagIssues("root", rootAgent)) {
+            issues.push(issue);
+        }
+        // Note: hints are injected at runtime by scoped-agent-file.ts; skip for root agent
+        const subagents = (rootAgent.subagents ?? {});
+        for (const [alias, value] of Object.entries(subagents)) {
+            const ref = value;
+            const path = typeof ref.path === "string" ? ref.path : "";
+            const match = path.match(/\.\/roles\/([^/]+)\.yaml$/);
+            if (!match) {
+                issues.push(`root subagent ${alias}: invalid role path ${path || "(missing)"}`);
+                continue;
+            }
+            if (!agentsById.has(match[1])) {
+                issues.push(`root subagent ${alias}: missing role agent ${match[1]}`);
+            }
+        }
+    }
+    for (const a of agents) {
+        const content = await readFile(a.filePath, "utf-8");
+        if (!content.includes("agent:")) {
+            issues.push(`${a.id}: missing 'agent:' root key`);
+        }
+        if (!a.role) {
+            issues.push(`${a.id}: missing OMK_ROLE in system_prompt_args`);
+        }
+        const doc = YAML.parse(content);
+        const agent = (doc?.agent ?? {});
+        if (okabeHealthy && String(agent.extend ?? "") !== "../okabe.yaml") {
+            issues.push(`${a.id}: expected extend: ../okabe.yaml`);
+        }
+        for (const issue of missingCapabilityFlagIssues(a.id, agent)) {
+            issues.push(issue);
+        }
+        // Note: role agents do not have static hints; hints are injected at runtime
+        // by scoped-agent-file.ts based on preset/skill assignment. Skip hint checks.
+    }
+    // Check for stable agents
+    for (const id of STABLE_AGENTS) {
+        if (!agents.some((a) => a.id === id)) {
+            issues.push(`Missing stable agent: ${id}`);
+        }
+    }
+    console.log(header("Agent Doctor"));
+    console.log(label("Agents checked", String(agents.length)));
+    if (issues.length === 0) {
+        console.log("");
+        console.log(status.success("All agents healthy."));
+    }
+    else {
+        console.log("");
+        console.log(status.warn(`${issues.length} issue(s) found:`));
+        for (const issue of issues) {
+            console.log(bullet(issue));
+        }
+    }
+}
+function missingCapabilityFlagIssues(id, agent) {
+    const issues = [];
+    const promptArgs = (agent.system_prompt_args ?? {});
+    for (const flag of CAPABILITY_FLAGS) {
+        if (String(promptArgs[flag]) !== "true") {
+            issues.push(`${id}: missing ${flag}=true in system_prompt_args`);
+        }
+    }
+    return issues;
+}
+function parseTopFromHint(hint) {
+    if (!hint)
+        return undefined;
+    const topMatch = hint.match(/top=([^;]*)/);
+    if (!topMatch)
+        return undefined;
+    const top = topMatch[1].trim();
+    if (!top)
+        return undefined;
+    return top.split("|").filter(Boolean);
+}

package/dist/commands/appshot.d.ts

@@ -0,0 +1,15 @@
+interface AppShotOptions {
+    json?: boolean;
+    activeWindow?: boolean;
+    screen?: boolean;
+    goalId?: string;
+    runId?: string;
+    days?: string;
+    dryRun?: boolean;
+}
+export declare function appshotCaptureCommand(options: AppShotOptions): Promise<void>;
+export declare function appshotAskCommand(question: string, options: AppShotOptions): Promise<void>;
+export declare function appshotDirCommand(options: AppShotOptions): Promise<void>;
+export declare function appshotListCommand(options: AppShotOptions): Promise<void>;
+export declare function appshotCleanCommand(options: AppShotOptions): Promise<void>;
+export {};

package/dist/commands/appshot.js

@@ -0,0 +1,122 @@
+import { writeFileSync } from "node:fs";
+import { getProjectRoot } from "../util/fs.js";
+import { captureAppShot, getAppShotDir, listAppShots, cleanAppShots, } from "../util/appshot-store.js";
+import { style, status, header, label } from "../util/theme.js";
+function output(data, json, human) {
+    if (json) {
+        console.log(JSON.stringify(data));
+    }
+    else {
+        console.log(human);
+    }
+}
+export async function appshotCaptureCommand(options) {
+    const root = getProjectRoot();
+    let captureType = "active-window";
+    if (options.screen) {
+        captureType = "screen";
+    }
+    const result = captureAppShot(root, {
+        captureType,
+        goalId: options.goalId,
+        runId: options.runId,
+    });
+    if (!result.ok) {
+        if (options.json) {
+            console.log(JSON.stringify({ ok: false, error: result.error }));
+        }
+        else {
+            console.error(status.error(result.error ?? "Failed to capture appshot"));
+        }
+        process.exit(1);
+    }
+    output({
+        ok: true,
+        path: result.path,
+        relativePath: result.relativePath,
+        metadataPath: result.metadataPath,
+    }, options.json, status.ok(`Appshot saved: ${result.relativePath}`));
+}
+export async function appshotAskCommand(question, options) {
+    const root = getProjectRoot();
+    let captureType = "active-window";
+    if (options.screen) {
+        captureType = "screen";
+    }
+    const result = captureAppShot(root, {
+        captureType,
+        goalId: options.goalId,
+        runId: options.runId,
+    });
+    if (!result.ok) {
+        if (options.json) {
+            console.log(JSON.stringify({ ok: false, error: result.error }));
+        }
+        else {
+            console.error(status.error(result.error ?? "Failed to capture appshot"));
+        }
+        process.exit(1);
+    }
+    const visionPromptPath = result.path
+        ? result.path.replace(/\.[^.]+$/, "") + "-vision-prompt.md"
+        : undefined;
+    if (visionPromptPath && result.path) {
+        const content = `# Vision Prompt\n\nQuestion: ${question}\n\nImage: ${result.relativePath ?? result.path}\nCaptured: ${new Date().toISOString()}\n`;
+        writeFileSync(visionPromptPath, content, "utf-8");
+    }
+    output({
+        ok: true,
+        path: result.path,
+        relativePath: result.relativePath,
+        metadataPath: result.metadataPath,
+        visionPromptPath,
+        question,
+    }, options.json, status.ok(`Appshot saved with question: ${style.cream(question)}`));
+}
+export async function appshotDirCommand(options) {
+    const dir = getAppShotDir();
+    output({ dir }, options.json, label("Appshot directory", dir));
+}
+export async function appshotListCommand(options) {
+    const entries = listAppShots();
+    if (options.json) {
+        console.log(JSON.stringify({ entries }));
+        return;
+    }
+    if (entries.length === 0) {
+        console.log(style.gray("No appshots found."));
+        return;
+    }
+    console.log(header("Appshots"));
+    for (const e of entries) {
+        const sizeKb = (e.size / 1024).toFixed(1);
+        const date = new Date(e.mtimeMs).toISOString().slice(0, 19).replace("T", " ");
+        console.log(`  ${date}  ${sizeKb.padStart(6)} KB  ${e.relativePath}`);
+    }
+}
+export async function appshotCleanCommand(options) {
+    const days = Math.max(0, parseInt(options.days ?? "7", 10));
+    const dryRun = Boolean(options.dryRun);
+    const result = cleanAppShots(days, dryRun);
+    if (options.json) {
+        console.log(JSON.stringify({ days, dryRun, ...result }));
+        return;
+    }
+    if (dryRun) {
+        console.log(header(`Dry run — would delete appshots older than ${days} days`));
+    }
+    else {
+        console.log(header(`Deleted appshots older than ${days} days`));
+    }
+    if (result.deleted.length === 0) {
+        console.log(style.gray("No appshots to delete."));
+    }
+    else {
+        for (const p of result.deleted) {
+            console.log(`  ${dryRun ? "[would delete]" : "[deleted]"} ${p}`);
+        }
+    }
+    if (result.skipped.length > 0) {
+        console.log(style.gray(`\n  Kept ${result.skipped.length} newer appshot(s).`));
+    }
+}

package/dist/commands/auth.d.ts

@@ -0,0 +1,43 @@
+import type { ProviderId } from "../providers/types.js";
+export interface AuthCommandOptions {
+    json?: boolean;
+    doctor?: boolean;
+    setup?: boolean;
+    soft?: boolean;
+}
+export interface AuthCenterProviderStatus {
+    provider: ProviderId;
+    label: string;
+    enabled: boolean;
+    configured: boolean;
+    available: boolean;
+    authMethod: string;
+    kind: string;
+    runtime: string;
+    defaultModel: string;
+    apiKeyEnv?: string;
+    apiKeyEnvPresent?: boolean | "unknown";
+    authority: "authority" | "advisory";
+    routing?: string;
+    reason: string;
+    nextActions: string[];
+}
+export interface AuthCenterReport {
+    schema: "omk.auth-center/status.v1";
+    ok: boolean;
+    command: "auth";
+    checkedAt: string;
+    mode: "metadata-only";
+    defaultProvider: string;
+    authorityProvider: string;
+    model?: string;
+    providers: AuthCenterProviderStatus[];
+    tokenFilesRead: false;
+    secretValuesRead: false;
+    secretValuesPrinted: false;
+    projectFilesWritten: false;
+}
+export declare function authCommand(provider?: string, options?: AuthCommandOptions): Promise<void>;
+export declare function buildAuthCenterReport(provider?: string, options?: {
+    env?: NodeJS.ProcessEnv;
+}): Promise<AuthCenterReport>;

package/dist/commands/auth.js

@@ -0,0 +1,167 @@
+import { readProviderDefaults, readProviderRegistry, normalizeProviderId } from "../providers/model-registry.js";
+import { DEFAULT_AUTHORITY_PROVIDER } from "../providers/types.js";
+import { checkCommand } from "../util/shell.js";
+import { style, box } from "../util/theme.js";
+export async function authCommand(provider, options = {}) {
+    const report = await buildAuthCenterReport(provider, { env: process.env });
+    if (options.json) {
+        console.log(JSON.stringify(report, null, 2));
+    }
+    else {
+        renderAuthCenter(report, options);
+    }
+    if (!report.ok && !options.soft) {
+        process.exitCode = 1;
+    }
+}
+export async function buildAuthCenterReport(provider, options = {}) {
+    const env = options.env ?? process.env;
+    const defaults = await readProviderDefaults({ env });
+    const authorityProvider = normalizeProviderId(defaults.authorityProvider ?? env.OMK_AUTHORITY_PROVIDER ?? env.OMK_DEFAULT_PROVIDER ?? DEFAULT_AUTHORITY_PROVIDER);
+    const defaultProvider = normalizeProviderId(defaults.provider ?? env.OMK_DEFAULT_PROVIDER ?? "auto");
+    const target = provider ? normalizeProviderId(provider) : undefined;
+    const registry = await readProviderRegistry({ env });
+    const entries = target && target !== "auto"
+        ? registry.filter((entry) => entry.id === target)
+        : registry;
+    const providers = await Promise.all(entries.map((entry) => buildProviderStatus(entry, authorityProvider, env)));
+    return {
+        schema: "omk.auth-center/status.v1",
+        ok: target === undefined || target === "auto" ? providers.length > 0 : providers.every((entry) => entry.available),
+        command: "auth",
+        checkedAt: new Date().toISOString(),
+        mode: "metadata-only",
+        defaultProvider,
+        authorityProvider: authorityProvider === "auto" ? DEFAULT_AUTHORITY_PROVIDER : authorityProvider,
+        model: defaults.model,
+        providers,
+        tokenFilesRead: false,
+        secretValuesRead: false,
+        secretValuesPrinted: false,
+        projectFilesWritten: false,
+    };
+}
+async function buildProviderStatus(entry, authorityProvider, env) {
+    const runtime = runtimeName(entry);
+    const authMethod = entry.auth?.method ?? "api-key-env";
+    const label = providerLabel(entry.id);
+    const nextActions = setupActions(entry);
+    let available = entry.enabled;
+    let apiKeyEnvPresent = "unknown";
+    let reason = "metadata only; run provider doctor explicitly for health";
+    if (entry.kind === "openai-compatible") {
+        apiKeyEnvPresent = entry.apiKeyEnv ? Boolean(env[entry.apiKeyEnv]?.trim()) : false;
+        available = entry.enabled && apiKeyEnvPresent === true;
+        reason = available ? "API-key env is present" : `Missing ${entry.apiKeyEnv ?? "provider API key"} environment variable`;
+    }
+    else if (entry.kind === "codex-cli" || entry.kind === "external-cli" || entry.kind === "kimi-native") {
+        const command = commandForProvider(entry.id, env);
+        const commandOk = command ? await checkCommand(command).catch(() => false) : entry.enabled;
+        available = entry.enabled && commandOk;
+        reason = available ? `${command ?? runtime} runtime command is available` : `${command ?? runtime} runtime command is missing or disabled`;
+        apiKeyEnvPresent = undefined;
+    }
+    return {
+        provider: entry.id,
+        label,
+        enabled: entry.enabled,
+        configured: entry.configured,
+        available,
+        authMethod,
+        kind: entry.kind,
+        runtime,
+        defaultModel: entry.defaultModel,
+        apiKeyEnv: entry.apiKeyEnv,
+        apiKeyEnvPresent,
+        authority: entry.id === authorityProvider ? "authority" : "advisory",
+        routing: entry.routing,
+        reason,
+        nextActions: available ? [] : nextActions,
+    };
+}
+function renderAuthCenter(report, options) {
+    const lines = [];
+    lines.push(style.phosphorBold("OMK Auth Center"));
+    lines.push(style.phosphorDim(`Default provider: ${report.defaultProvider}`));
+    lines.push(style.phosphorDim(`Authority: ${report.authorityProvider}`));
+    if (report.model)
+        lines.push(style.phosphorDim(`Model: ${report.model}`));
+    lines.push("");
+    for (const provider of report.providers) {
+        const mark = provider.available ? style.phosphorBold("✓") : provider.enabled ? style.phosphorDim("○") : style.phosphorDim("×");
+        const state = provider.available ? "runtime ready" : provider.enabled ? "needs setup" : "disabled";
+        const auth = provider.apiKeyEnv ? `${provider.authMethod} ${provider.apiKeyEnv}` : provider.authMethod;
+        lines.push(`  ${mark} ${style.phosphor(provider.provider.padEnd(12))} ${style.phosphorDim(state.padEnd(14))} ${style.phosphorDim(auth)}`);
+        if ((options.doctor || options.setup) && provider.nextActions.length > 0) {
+            for (const action of provider.nextActions.slice(0, 3))
+                lines.push(style.phosphorDim(`      - ${action}`));
+        }
+    }
+    lines.push("");
+    lines.push(style.phosphorDim("Secret policy: tokenFilesRead=false, secretValuesPrinted=false"));
+    if (!options.setup) {
+        lines.push(style.phosphorDim("Use `omk auth <provider> --setup` for setup actions."));
+    }
+    console.log(box(lines, "Auth Center"));
+}
+function commandForProvider(provider, env) {
+    if (provider === "codex")
+        return env.CODEX_BIN ?? "codex";
+    if (provider === "opencode")
+        return env.OPENCODE_BIN ?? "opencode";
+    if (provider === "commandcode")
+        return env.COMMANDCODE_BIN ?? "commandcode";
+    return undefined;
+}
+function runtimeName(entry) {
+    if (entry.id === "kimi")
+        return "kimi-api";
+    if (entry.id === "codex")
+        return "codex-cli";
+    if (entry.id === "deepseek")
+        return "deepseek-api";
+    if (entry.id === "openrouter")
+        return "openrouter-api";
+    if (entry.id === "qwen")
+        return "qwen-api";
+    if (entry.id === "opencode")
+        return "opencode-cli";
+    if (entry.id === "commandcode")
+        return "commandcode-cli";
+    return `${entry.id}-api`;
+}
+function providerLabel(provider) {
+    if (provider === "kimi")
+        return "Kimi for Coding";
+    if (provider === "codex")
+        return "OpenAI Codex";
+    if (provider === "deepseek")
+        return "DeepSeek";
+    if (provider === "opencode")
+        return "OpenCode";
+    if (provider === "commandcode")
+        return "CommandCode";
+    if (provider === "openrouter")
+        return "OpenRouter";
+    if (provider === "qwen")
+        return "Qwen/DashScope";
+    return provider;
+}
+function setupActions(entry) {
+    if (entry.kind === "openai-compatible") {
+        return [
+            `export ${entry.apiKeyEnv ?? "PROVIDER_API_KEY"}=...`,
+            `omk provider auth ${entry.id} --method api-key-env --api-key-env ${entry.apiKeyEnv ?? "PROVIDER_API_KEY"}`,
+            `omk provider doctor ${entry.id} --soft`,
+        ];
+    }
+    if (entry.id === "kimi")
+        return ["export KIMI_API_KEY=...", "omk provider doctor kimi --soft", "Optional: set KIMI_MODEL=..."];
+    if (entry.id === "codex")
+        return ["npm install -g @openai/codex", "codex login"];
+    if (entry.id === "opencode")
+        return ["cargo install opencode", "opencode login"];
+    if (entry.id === "commandcode")
+        return ["npm install -g commandcode", "commandcode login"];
+    return [`omk provider doctor ${entry.id} --soft`];
+}

package/dist/commands/browser.d.ts

@@ -0,0 +1,18 @@
+interface BrowserOptions {
+    json?: boolean;
+    headless?: boolean;
+    session?: string;
+}
+export declare function browserOpenCommand(url: string, options: BrowserOptions): Promise<void>;
+export declare function browserInspectCommand(options: BrowserOptions & {
+    session?: string;
+}): Promise<void>;
+export declare function browserFeedbackCommand(text: string, options: BrowserOptions & {
+    session?: string;
+}): Promise<void>;
+export declare function browserRepairCommand(instruction: string, options: BrowserOptions & {
+    session?: string;
+}): Promise<void>;
+export declare function browserCloseCommand(options: BrowserOptions): Promise<void>;
+export declare function browserDirCommand(options: BrowserOptions): Promise<void>;
+export {};