@litfamily/litopencode 1.0.0

package/dist/cli/install-report.js

@@ -0,0 +1,180 @@
+const reset = "\u001b[0m";
+const green = "\u001b[38;5;82m";
+const cyan = "\u001b[1;38;5;81m";
+const muted = "\u001b[38;5;245m";
+function useColor() {
+    return process.stdout.isTTY === true && process.env.NO_COLOR === undefined && process.env.CI === undefined;
+}
+function tint(value, code) {
+    if (!useColor())
+        return value;
+    return code + value + reset;
+}
+function padLabel(label) {
+    return label.padEnd(18, " ");
+}
+function cellWidth(value) {
+    let width = 0;
+    for (const character of value) {
+        const codePoint = character.codePointAt(0) ?? 0;
+        if (/\p{Mark}/u.test(character) || codePoint === 0x200d)
+            continue;
+        const wide = codePoint >= 0x1100 &&
+            (codePoint <= 0x115f ||
+                codePoint === 0x2329 ||
+                codePoint === 0x232a ||
+                (codePoint >= 0x2e80 && codePoint <= 0xa4cf) ||
+                (codePoint >= 0xac00 && codePoint <= 0xd7a3) ||
+                (codePoint >= 0xf900 && codePoint <= 0xfaff) ||
+                (codePoint >= 0xfe10 && codePoint <= 0xfe6f) ||
+                (codePoint >= 0xff00 && codePoint <= 0xff60) ||
+                (codePoint >= 0x1f300 && codePoint <= 0x1faff));
+        width += wide ? 2 : 1;
+    }
+    return width;
+}
+function splitLongWord(word, width) {
+    const chunks = [];
+    let chunk = "";
+    for (const character of word) {
+        if (chunk.length > 0 && cellWidth(chunk + character) > width) {
+            chunks.push(chunk);
+            chunk = character;
+        }
+        else {
+            chunk += character;
+        }
+    }
+    if (chunk.length > 0)
+        chunks.push(chunk);
+    return chunks;
+}
+function wrapValue(value, width) {
+    const words = value.trim().split(/\s+/u).flatMap((word) => splitLongWord(word, width));
+    const wrapped = [];
+    let current = "";
+    for (const word of words) {
+        const candidate = current.length === 0 ? word : current + " " + word;
+        if (current.length > 0 && cellWidth(candidate) > width) {
+            wrapped.push(current);
+            current = word;
+        }
+        else {
+            current = candidate;
+        }
+    }
+    if (current.length > 0)
+        wrapped.push(current);
+    return wrapped.length > 0 ? wrapped : [""];
+}
+function line(label, value) {
+    const prefix = "  " + padLabel(label) + " ";
+    const continuation = " ".repeat(prefix.length);
+    return wrapValue(value, 80 - prefix.length)
+        .map((part, index) => (index === 0 ? prefix : continuation) + part)
+        .join("\n");
+}
+function section(title) {
+    return ["", "  " + tint(title, muted)];
+}
+function modelRoute(report) {
+    const model = report.litopencodeConfig.model;
+    if (model.provider && model.model) {
+        const lead = model.provider + "/" + model.model;
+        return model.helper === undefined ? lead : lead + " lead; " + model.helper.provider + "/" + model.helper.model + " helpers";
+    }
+    if (model.classification.originalDispatchId)
+        return model.classification.originalDispatchId;
+    if (model.classification.class === "fresh")
+        return "Role-split shipped defaults";
+    return "OpenCode session default";
+}
+function existingRoute(report) {
+    const model = report.litopencodeConfig.model;
+    if (model.classification.originalDispatchId === null)
+        return model.classification.class;
+    return model.classification.originalDispatchId + (model.existingVariant === undefined ? "" : " (" + model.existingVariant + ")");
+}
+function permissionRoute(report) {
+    if (report.litopencodeConfig.permissionMode.mode === "balanced") {
+        return "Balanced (allow routine work; ask for dangerous bash)";
+    }
+    if (report.litopencodeConfig.permissionMode.mode === "yolo") {
+        return "YOLO (allow bash/edit/task/webfetch/external_directory; lit-plan stays deny)";
+    }
+    return "Safe / ask-first";
+}
+function actionLines(report) {
+    const pluginChanged = report.patch.length > 0;
+    const routeAction = report.litopencodeConfig.changed
+        ? report.litopencodeConfig.alreadyPresent
+            ? "litopencode.json updated"
+            : "litopencode.json created"
+        : "litopencode.json preserved";
+    return [
+        pluginChanged ? "plugin[] updated" : "plugin[] already ready",
+        routeAction,
+        report.hostLimits.reconfigure
+            ? report.hostLimits.changed
+                ? "OpenCode context and compaction limits updated"
+                : "OpenCode context and compaction limits already ready"
+            : "OpenCode context and compaction limits preserved; select LUNA to reconfigure",
+        report.commandAliases.changed ? "command aliases written" : "command aliases preserved",
+        report.nativeSkills.changed ? "native skills written" : "native skills preserved"
+    ];
+}
+function progressLine(label) {
+    return "  " + tint("[ok]", green) + " " + label;
+}
+function headerLine(label, code) {
+    return "| " + tint(label.padEnd(58, " "), code) + " |";
+}
+export function renderInstallReport(report) {
+    const changed = report.changed || report.litopencodeConfig.changed || report.commandAliases.changed;
+    const status = changed ? "Complete" : "Already installed";
+    const actions = actionLines(report);
+    return [
+        "+------------------------------------------------------------+",
+        headerLine("LitOpenCode installer", cyan),
+        headerLine("OpenCode plugin setup", muted),
+        "+------------------------------------------------------------+",
+        ...section("Install summary"),
+        line("Package", report.package.name + "@" + report.package.version),
+        line("Status", status),
+        line("Result", actions[0]),
+        line("", actions[1]),
+        line("", actions[2]),
+        line("", actions[3]),
+        line("", actions[4]),
+        ...section("Routes"),
+        line("Model", modelRoute(report)),
+        line("Effort", report.litopencodeConfig.model.effort ?? "preserve existing"),
+        line("Existing route", existingRoute(report)),
+        line("Route class", report.litopencodeConfig.model.classification.class),
+        line("Permissions", permissionRoute(report)),
+        line("Authority lifecycle", "schema 3; bounded history/context; trusted resume only"),
+        line("Agents", "lit-loop, lit-plan, lit-implement"),
+        line("Shipped defaults", "Astra/xhigh lead + planning/review; LUNA/max execution/research helpers"),
+        line("Override order", "project merges after global; per-agent routes override categories"),
+        line("Coverage", report.litopencodeConfig.agents.length + " agents / " + report.litopencodeConfig.categories.length + " categories"),
+        ...section("Host capabilities"),
+        line("Context ceiling 372K", report.capabilities.contextCeiling372k.status),
+        line("Compaction 334.8K", report.capabilities.autoCompaction334800.status),
+        line("Concurrency 20", report.capabilities.subagentConcurrency20.status),
+        ...section("Files"),
+        line("OpenCode config", report.path),
+        line("Host limits", report.hostLimits.path),
+        line("LitOpenCode config", report.litopencodeConfig.path),
+        line("Command aliases", report.commandAliases.write.length + " managed / " + report.commandAliases.preserve.length + " preserved"),
+        line("Native skills", report.nativeSkills.write.length + " managed / " + report.nativeSkills.preserve.length + " preserved"),
+        line("Plugin entries", report.plugin.currentCount + " -> " + report.plugin.resultCount),
+        ...section("Progress"),
+        progressLine("Resolve package"),
+        progressLine("Read OpenCode config"),
+        progressLine("Write litopencode.json"),
+        progressLine("Register plugin"),
+        progressLine("Verify install"),
+        ...section("Next"),
+        "  Restart OpenCode, press Tab, then choose lit-loop, lit-plan, or lit-implement."
+    ].join("\n");
+}

package/dist/cli/install-tui.d.ts

@@ -0,0 +1,12 @@
+import type { InstallProgress, InstallStageLabel } from "./types.ts";
+type InstallStageState = "running" | "complete" | "failed";
+type TextOutput = {
+    write(value: string): unknown;
+};
+export declare function renderLitOpenCodeWordmark(packageLabel: string, colorEnabled?: boolean): string;
+export declare function renderInstallTuiLogo(packageLabel: string): string;
+export declare function renderInstallTuiStage(label: InstallStageLabel, state: InstallStageState, frameIndex: number): string;
+export declare function renderInstallTuiCompletion(): string;
+export declare function shouldRenderInstallTui(argv: readonly string[]): boolean;
+export declare function createInstallTui(output?: TextOutput): InstallProgress;
+export {};

package/dist/cli/install-tui.js

@@ -0,0 +1,174 @@
+import { banner, colorize, lockup, markColorMode, supportsMarkGlyphs } from "../lit-mark.js";
+const reset = "\u001b[0m";
+const bold = "\u001b[1m";
+const green = "\u001b[38;5;82m";
+const muted = "\u001b[38;5;245m";
+const amber = "\u001b[38;5;221m";
+const litLoopOrange = "\u001b[38;2;255;90;31m";
+const litPlanYellow = "\u001b[38;2;250;204;21m";
+const boxContentWidth = 56;
+const spinnerFrames = ["⠋", "⠙", "⠹", "⠸", "⠼", "⠴", "⠦", "⠧", "⠇", "⠏"];
+const installStages = [
+    {
+        index: 1,
+        label: "Resolve package",
+        code: "PACKAGE",
+        purpose: "Resolve package root and the host-native install source",
+        active: "Resolving package identity",
+        complete: "Package source resolved"
+    },
+    {
+        index: 2,
+        label: "Read OpenCode config",
+        code: "HOST CONFIG",
+        purpose: "Inspect plugin entries without exposing stored secrets",
+        active: "Inspecting OpenCode configuration",
+        complete: "OpenCode config inspected"
+    },
+    {
+        index: 3,
+        label: "Write litopencode.json",
+        code: "ROUTES & SKILLS",
+        purpose: "Write role routes, commands, and native skill surfaces",
+        active: "Writing LitOpenCode surfaces",
+        complete: "Routes, commands, and skills ready"
+    },
+    {
+        index: 4,
+        label: "Register plugin",
+        code: "PLUGIN",
+        purpose: "Register through OpenCode or patch the requested custom root",
+        active: "Registering plugin with OpenCode",
+        complete: "Plugin registered"
+    },
+    {
+        index: 5,
+        label: "Verify install",
+        code: "HEALTH CHECK",
+        purpose: "Confirm the installer surface completed cleanly",
+        active: "Verifying installed surfaces",
+        complete: "Install surface verified"
+    }
+];
+function sleep(milliseconds) {
+    return new Promise((resolve) => setTimeout(resolve, milliseconds));
+}
+function color(value, code) {
+    if (markColorMode() === "none")
+        return value;
+    return code + value + reset;
+}
+function boxTop(title) {
+    return "╭─ " + title + " " + "─".repeat(boxContentWidth - title.length - 1) + "╮";
+}
+function boxLine(value) {
+    return "│ " + value.padEnd(boxContentWidth, " ") + " │";
+}
+function boxBottom() {
+    return "╰" + "─".repeat(boxContentWidth + 2) + "╯";
+}
+function findStage(label) {
+    const stage = installStages.find((candidate) => candidate.label === label);
+    if (stage === undefined)
+        throw new Error("Unknown install stage: " + String(label));
+    return stage;
+}
+function stageHeader(stage) {
+    const number = String(stage.index).padStart(2, "0") + " / " + String(installStages.length).padStart(2, "0");
+    return "\n  " + color(number, amber) + "  " + color(stage.code, bold) + "\n       " + color(stage.purpose, muted) + "\n";
+}
+function stageStateLine(stage, state, frameIndex) {
+    if (state === "complete")
+        return "  " + color("✓", green) + " " + stage.complete;
+    if (state === "failed")
+        return "  " + color("×", amber) + " " + stage.label + " stopped";
+    const frame = spinnerFrames[frameIndex % spinnerFrames.length];
+    return "  " + color(frame, amber) + " " + stage.active;
+}
+function clearLine(output) {
+    output.write(markColorMode() !== "none" ? "\r\u001b[2K" : "\r");
+}
+const bannerRule = "  " + "━".repeat(46);
+function productVersion(packageLabel) {
+    const at = packageLabel.lastIndexOf("@");
+    return at > 0 ? packageLabel.slice(at + 1) : packageLabel;
+}
+export function renderLitOpenCodeWordmark(packageLabel, colorEnabled = true) {
+    const product = "litopencode v" + productVersion(packageLabel);
+    if (!supportsMarkGlyphs())
+        return "LIT\n" + product;
+    return colorize(lockup(product, banner), { mode: colorEnabled ? markColorMode() : "none" }).join("\n");
+}
+export function renderInstallTuiLogo(packageLabel) {
+    const stageRows = installStages.map((stage) => "  │ " + color(String(stage.index).padStart(2, "0"), litPlanYellow) + " · " + stage.label.split(" ")[0].padEnd(10, " ") + " " + color(stage.purpose, muted));
+    return [
+        "",
+        color(bannerRule, litLoopOrange),
+        "",
+        renderLitOpenCodeWordmark(packageLabel),
+        "       " + color("OpenCode plugin installer · visible progress, explicit receipts", muted),
+        "",
+        color(bannerRule, litLoopOrange),
+        "  ╭─ INSTALL",
+        ...stageRows,
+        "  ╰─ writes begin at 03 / 05 · " + packageLabel,
+        ""
+    ].join("\n") + "\n";
+}
+export function renderInstallTuiStage(label, state, frameIndex) {
+    const stage = findStage(label);
+    return stageHeader(stage) + stageStateLine(stage, state, frameIndex);
+}
+export function renderInstallTuiCompletion() {
+    return [
+        "",
+        color(boxTop("INSTALL READY"), green),
+        boxLine("Plugin, routes, commands, and skills are ready."),
+        boxLine("Next     Restart OpenCode · press Tab · choose lit-loop"),
+        color(boxBottom(), green),
+        ""
+    ].join("\n");
+}
+export function shouldRenderInstallTui(argv) {
+    return process.stdout.isTTY === true && process.env.CI === undefined && argv[0] === "install" && !argv.includes("--dry-run") && !argv.includes("--json");
+}
+export function createInstallTui(output = process.stdout) {
+    let frameIndex = 0;
+    function paint(stage) {
+        clearLine(output);
+        output.write(stageStateLine(stage, "running", frameIndex));
+        frameIndex += 1;
+    }
+    return {
+        async start(packageLabel) {
+            output.write(renderInstallTuiLogo(packageLabel));
+            await sleep(80);
+        },
+        async run(label, task) {
+            const stage = findStage(label);
+            output.write(stageHeader(stage));
+            paint(stage);
+            const timer = setInterval(() => paint(stage), 80);
+            try {
+                const result = await task();
+                clearInterval(timer);
+                clearLine(output);
+                output.write(stageStateLine(stage, "complete", frameIndex) + "\n");
+                return result;
+            }
+            catch (error) {
+                clearInterval(timer);
+                clearLine(output);
+                output.write(stageStateLine(stage, "failed", frameIndex) + "\n");
+                throw error;
+            }
+        },
+        async complete() {
+            output.write(renderInstallTuiCompletion());
+        },
+        async fail(message) {
+            clearLine(output);
+            output.write("  " + color("×", amber) + " " + message + "\n\n");
+        }
+    };
+}

package/dist/cli/install.d.ts

@@ -0,0 +1,2 @@
+import type { CliResult, InstallModelSelection, InstallPermissionMode, InstallProgress, ModelPromptMode, PermissionPromptMode } from "./types.ts";
+export declare function install(root: string, dryRun: boolean, modelSelection?: InstallModelSelection | undefined, modelPrompt?: ModelPromptMode, permissionMode?: InstallPermissionMode, permissionModeExplicit?: boolean, permissionPrompt?: PermissionPromptMode, progress?: InstallProgress, outputStylePrompt?: PermissionPromptMode): Promise<CliResult>;

package/dist/cli/install.js

@@ -0,0 +1,264 @@
+import { execFile } from "node:child_process";
+import fs from "node:fs/promises";
+import os from "node:os";
+import path from "node:path";
+import { promisify } from "node:util";
+import { createRuntimePaths } from "../state.js";
+import { describeCommandAliasMutation, ensureCommandAliases, inspectCommandAliases } from "./command-aliases.js";
+import { openCodeHostCapabilities } from "./host-capabilities.js";
+import { describeHostLimitMutation, ensureHostLimits } from "./host-limits.js";
+import { assertExistingModelRoutesSafe, describeInstallRoutes, describeLitConfigMutation, ensureLitConfig, readExistingOutputStyle, readInstallModelClassification, readInstallModelSelection, writeTextAtomically } from "./install-config.js";
+import { readJsonObjectIfPresent, readPackageMetadata } from "./json.js";
+import { renderInstallReport } from "./install-report.js";
+import { renderLitOpenCodeWordmark } from "./install-tui.js";
+import { promptModelSelection, promptOutputStyle, promptPermissionMode } from "./model-routing.js";
+import { litOpenCodeConfigFileForOpenCodeRoot } from "../state.js";
+import { describeNativeSkillMutation, ensureNativeSkills, inspectNativeSkills } from "./native-skills.js";
+import { applyPluginMutation, describePluginMutation, isLitOpenCodeEntry } from "./plugin-mutation.js";
+const execFileAsync = promisify(execFile);
+function withProgress(progress, label, task) {
+    return progress === undefined ? task() : progress.run(label, task);
+}
+function pluginSpec(metadata) {
+    return metadata.name + "@" + metadata.version;
+}
+async function isLitOpenCodePathEntry(root, value) {
+    if (typeof value !== "string" || isLitOpenCodeEntry(value))
+        return false;
+    if (!(path.isAbsolute(value) || value.startsWith(".")))
+        return false;
+    const metadata = await readJsonObjectIfPresent(path.join(path.resolve(root, value), "package.json"));
+    return metadata?.name === "litopencode" || metadata?.name === "@litfamily/opencode" || metadata?.name === "@litfamily/litopencode";
+}
+function defaultOpenCodeRoot() {
+    const configHome = process.env.XDG_CONFIG_HOME;
+    if (configHome && configHome.length > 0)
+        return path.join(configHome, "opencode");
+    return path.join(os.homedir(), ".config", "opencode");
+}
+function shouldUseOpenCodeInstaller(root) {
+    return path.resolve(root) === path.resolve(defaultOpenCodeRoot());
+}
+function openCodeConfigCandidates(root) {
+    const resolvedRoot = path.resolve(root);
+    return [path.join(resolvedRoot, "opencode.json"), path.join(resolvedRoot, "opencode.jsonc")];
+}
+async function openCodeManagedConfigFile(root) {
+    const [jsonFile, jsoncFile] = openCodeConfigCandidates(root);
+    if (await pathExists(jsonFile))
+        return jsonFile;
+    if (await pathExists(jsoncFile))
+        return jsoncFile;
+    return jsoncFile;
+}
+function outputText(value) {
+    if (typeof value === "string")
+        return value;
+    if (value instanceof Uint8Array)
+        return Buffer.from(value).toString("utf8");
+    return "";
+}
+function stripAnsi(value) {
+    return value.replace(/\u001b\[[0-9;?]*[ -/]*[@-~]/g, "");
+}
+function commandFailureDetail(error) {
+    if (!(error instanceof Error))
+        return String(error);
+    const failure = error;
+    const parts = [];
+    const stderr = stripAnsi(outputText(failure.stderr)).trim();
+    const stdout = stripAnsi(outputText(failure.stdout)).trim();
+    const code = typeof failure.code === "number" || typeof failure.code === "string" ? String(failure.code) : "";
+    const signal = typeof failure.signal === "string" ? failure.signal : "";
+    if (stderr.length > 0)
+        parts.push("stderr:\n" + stderr);
+    if (stdout.length > 0)
+        parts.push("stdout:\n" + stdout);
+    if (code.length > 0)
+        parts.push("exit code: " + code);
+    if (signal.length > 0)
+        parts.push("signal: " + signal);
+    if (parts.length === 0 && error.message.length > 0)
+        parts.push(error.message);
+    return parts.join("\n\n");
+}
+async function pathExists(filePath) {
+    try {
+        await fs.stat(filePath);
+        return true;
+    }
+    catch (error) {
+        if (error instanceof Error && "code" in error && error.code === "ENOENT")
+            return false;
+        throw error;
+    }
+}
+async function isLocalSourcePackage(packageRoot) {
+    const realPackageRoot = await fs.realpath(packageRoot);
+    return (await pathExists(path.join(realPackageRoot, ".git"))) && (await pathExists(path.join(realPackageRoot, "src")));
+}
+async function openCodeInstallTarget(metadata) {
+    if (await isLocalSourcePackage(metadata.packageRoot)) {
+        const realPackageRoot = await fs.realpath(metadata.packageRoot);
+        return { value: realPackageRoot, label: metadata.name + "@" + metadata.version + " (local checkout)" };
+    }
+    const spec = pluginSpec(metadata);
+    return { value: spec, label: spec };
+}
+async function installWithOpenCode(target) {
+    try {
+        await execFileAsync("opencode", ["plugin", target.value, "--global", "--force"], {
+            timeout: 120_000,
+            maxBuffer: 1024 * 1024 * 4
+        });
+    }
+    catch (error) {
+        const detail = commandFailureDetail(error);
+        throw new Error("OpenCode plugin install failed for " + target.label + (detail ? ":\n" + detail : ""));
+    }
+}
+async function normalizeOpenCodeEntries(root, target) {
+    for (const configFile of openCodeConfigCandidates(root)) {
+        const config = await readJsonObjectIfPresent(configFile);
+        const pluginValue = config?.plugin;
+        if (!Array.isArray(pluginValue))
+            continue;
+        const nextPlugin = [];
+        let registered = false;
+        for (const entry of pluginValue) {
+            const id = Array.isArray(entry) ? entry[0] : entry;
+            if (id === target.value || isLitOpenCodeEntry(entry) || (await isLitOpenCodePathEntry(root, id))) {
+                if (!registered)
+                    nextPlugin.push(Array.isArray(entry) ? [target.value, ...entry.slice(1)] : target.value);
+                registered = true;
+            }
+            else {
+                nextPlugin.push(entry);
+            }
+        }
+        if (JSON.stringify(nextPlugin) === JSON.stringify(pluginValue))
+            continue;
+        await writeTextAtomically(configFile, JSON.stringify({ ...config, plugin: nextPlugin }, null, 2) + "\n");
+    }
+}
+async function verifyInstalledSurfaces(root, configFile, target, metadata, selectedModel, selectedPermissionMode, selectedPermissionExplicit, selectedOutputStyle) {
+    const config = await readJsonObjectIfPresent(configFile);
+    const pluginEntries = Array.isArray(config?.plugin) ? config.plugin : [];
+    const pluginIds = pluginEntries.map((entry) => typeof entry === "string" ? entry : Array.isArray(entry) && typeof entry[0] === "string" ? entry[0] : "");
+    const targetCount = pluginIds.filter((id) => id === target.value).length;
+    const staleLitEntries = pluginIds.filter((id) => id !== target.value && isLitOpenCodeEntry(id));
+    const litConfig = await describeLitConfigMutation(root, selectedModel, selectedPermissionMode, selectedPermissionExplicit, selectedOutputStyle);
+    const commandAliases = await inspectCommandAliases(root);
+    const nativeSkills = await inspectNativeSkills(root, metadata);
+    const failures = [];
+    if (targetCount !== 1 || staleLitEntries.length > 0)
+        failures.push("plugin registration");
+    if (litConfig.changed)
+        failures.push("LitOpenCode routes");
+    if (!commandAliases.ok)
+        failures.push("command aliases: " + commandAliases.missing.join(", "));
+    if (!nativeSkills.ok) {
+        const details = [...new Set([...nativeSkills.missing, ...nativeSkills.invalid])];
+        failures.push("native skills: " + details.join(", "));
+    }
+    if (metadata.name !== "@litfamily/litopencode")
+        failures.push("package identity");
+    if (failures.length > 0)
+        throw new Error("Install verification failed: " + failures.join("; "));
+}
+export async function install(root, dryRun, modelSelection = undefined, modelPrompt = "auto", permissionMode = "safe", permissionModeExplicit = false, permissionPrompt = "auto", progress, outputStylePrompt = "auto") {
+    await assertExistingModelRoutesSafe(root);
+    const classification = await readInstallModelClassification(root);
+    const currentModel = await readInstallModelSelection(root);
+    const existingOutputStyle = await readExistingOutputStyle(root);
+    const selectedModel = await promptModelSelection(modelSelection, modelPrompt, dryRun, classification, litOpenCodeConfigFileForOpenCodeRoot(root), currentModel);
+    const selectedPermission = await promptPermissionMode(permissionMode, permissionPrompt, dryRun);
+    const selectedOutputStyle = await promptOutputStyle(existingOutputStyle, outputStylePrompt, dryRun);
+    const selectedPermissionMode = selectedPermission.mode;
+    const selectedPermissionExplicit = permissionModeExplicit || selectedPermission.explicit;
+    const metadata = await readPackageMetadata();
+    const activeProgress = dryRun ? undefined : progress;
+    if (activeProgress !== undefined) {
+        await activeProgress.start(pluginSpec(metadata));
+    }
+    const spec = pluginSpec(metadata);
+    const resolved = await withProgress(activeProgress, "Resolve package", async () => {
+        const paths = createRuntimePaths(root);
+        const useOpenCodeInstaller = shouldUseOpenCodeInstaller(root);
+        const target = useOpenCodeInstaller ? await openCodeInstallTarget(metadata) : { value: spec, label: spec };
+        return { paths, useOpenCodeInstaller, target };
+    });
+    const inspected = await withProgress(activeProgress, "Read OpenCode config", async () => {
+        const configFile = resolved.useOpenCodeInstaller
+            ? await openCodeManagedConfigFile(root)
+            : resolved.paths.opencodeConfigFile;
+        const before = await readJsonObjectIfPresent(configFile);
+        return {
+            configFile,
+            before,
+            mutation: describePluginMutation(before, resolved.target.value),
+            litopencodeConfig: await describeLitConfigMutation(root, selectedModel, selectedPermissionMode, selectedPermissionExplicit, selectedOutputStyle),
+            commandAliases: await describeCommandAliasMutation(root),
+            nativeSkills: await describeNativeSkillMutation(root, metadata),
+            hostLimits: describeHostLimitMutation(before, selectedModel !== undefined),
+            routes: dryRun
+                ? await describeInstallRoutes(root, before, selectedModel, selectedPermissionMode, selectedPermissionExplicit, selectedOutputStyle)
+                : undefined
+        };
+    });
+    const { configFile, before, mutation, litopencodeConfig, commandAliases, nativeSkills, hostLimits, routes } = inspected;
+    const report = {
+        dryRun,
+        path: configFile,
+        litopencodeConfig,
+        plugin: mutation.plugin,
+        commandAliases,
+        nativeSkills,
+        patch: mutation.patch,
+        changed: mutation.changed || litopencodeConfig.changed || commandAliases.changed || nativeSkills.changed || hostLimits.changed,
+        routes,
+        hostLimits: { path: configFile, ...hostLimits },
+        capabilities: openCodeHostCapabilities(),
+        package: { name: metadata.name, version: metadata.version }
+    };
+    if (dryRun) {
+        return { exitCode: 0, stdout: JSON.stringify(report, null, 2) };
+    }
+    if (nativeSkills.collisions.length > 0) {
+        throw new Error("Native skill collision: refusing to overwrite pre-existing roots without managed entrypoints: " +
+            nativeSkills.collisions.join(", "));
+    }
+    await withProgress(activeProgress, "Write litopencode.json", async () => {
+        await ensureLitConfig(root, selectedModel, selectedPermissionMode, selectedPermissionExplicit, selectedOutputStyle);
+        await ensureCommandAliases(root);
+        await ensureNativeSkills(root, metadata);
+    });
+    await withProgress(activeProgress, "Register plugin", async () => {
+        if (resolved.useOpenCodeInstaller) {
+            await installWithOpenCode(resolved.target);
+            const installed = await readJsonObjectIfPresent(configFile);
+            if (!Array.isArray(installed?.plugin) || !installed.plugin.some((entry) => (Array.isArray(entry) ? entry[0] : entry) === resolved.target.value))
+                throw new Error("OpenCode did not register the requested package target");
+            await normalizeOpenCodeEntries(root, resolved.target);
+            await ensureHostLimits(configFile, await readJsonObjectIfPresent(configFile), hostLimits.reconfigure);
+            return;
+        }
+        const next = applyPluginMutation(before, mutation, resolved.target.value);
+        if (hostLimits.reconfigure) {
+            await ensureHostLimits(configFile, next, true);
+            return;
+        }
+        if (!mutation.changed)
+            return;
+        await fs.mkdir(path.dirname(configFile), { recursive: true });
+        await writeTextAtomically(configFile, JSON.stringify(next, null, 2) + "\n");
+    });
+    await withProgress(activeProgress, "Verify install", async () => verifyInstalledSurfaces(root, configFile, resolved.target, metadata, selectedModel, selectedPermissionMode, selectedPermissionExplicit, selectedOutputStyle));
+    await activeProgress?.complete();
+    return {
+        exitCode: 0,
+        stdout: activeProgress === undefined
+            ? renderLitOpenCodeWordmark(pluginSpec(metadata), false) + "\n" + renderInstallReport(report)
+            : undefined
+    };
+}

package/dist/cli/json.d.ts

@@ -0,0 +1,4 @@
+import type { PackageMetadata } from "./types.ts";
+export declare function isRecord(value: unknown): value is Record<string, unknown>;
+export declare function readPackageMetadata(): Promise<PackageMetadata>;
+export declare function readJsonObjectIfPresent(filePath: string): Promise<Record<string, unknown> | null>;

package/dist/cli/json.js

@@ -0,0 +1,31 @@
+import fs from "node:fs/promises";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+export function isRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+export async function readPackageMetadata() {
+    const packageRoot = path.resolve(path.dirname(fileURLToPath(import.meta.url)), "../..");
+    const packagePath = path.join(packageRoot, "package.json");
+    const parsed = JSON.parse(await fs.readFile(packagePath, "utf8"));
+    if (!isRecord(parsed) || typeof parsed.name !== "string" || typeof parsed.version !== "string") {
+        throw new Error(`Malformed package metadata at ${packagePath}`);
+    }
+    return { name: parsed.name, version: parsed.version, packageRoot };
+}
+export async function readJsonObjectIfPresent(filePath) {
+    let raw;
+    try {
+        raw = await fs.readFile(filePath, "utf8");
+    }
+    catch (error) {
+        if (error instanceof Error && "code" in error && error.code === "ENOENT")
+            return null;
+        throw error;
+    }
+    const parsed = JSON.parse(raw);
+    if (!isRecord(parsed)) {
+        throw new Error(`Malformed JSON at ${filePath}: expected an object.`);
+    }
+    return parsed;
+}