jishushell 0.4.10 → 0.4.24

package/dist/cli/app.js

@@ -0,0 +1,814 @@
+import { existsSync, readFileSync } from "fs";
+import { stringify } from "yaml";
+import { parseFlag } from "./helpers.js";
+import { loadManagedListEntries, printManagedList } from "./managed-list.js";
+import { ensureNomadToken, execInInstance, getInstanceLogs, getInstanceStatus, readInstanceMeta, restartNomadJobInstance, startNomadJobInstance, stopNomadJobInstance, } from "../services/nomad-manager.js";
+import { getTask, subscribeTask } from "../services/task-registry.js";
+// ── ANSI colour helpers ───────────────────────────────────────────────────
+const isTTY = process.stdout.isTTY ?? false;
+const c = {
+    bold: (s) => isTTY ? `\x1b[1m${s}\x1b[0m` : s,
+    green: (s) => isTTY ? `\x1b[32m${s}\x1b[0m` : s,
+    yellow: (s) => isTTY ? `\x1b[33m${s}\x1b[0m` : s,
+    red: (s) => isTTY ? `\x1b[31m${s}\x1b[0m` : s,
+    cyan: (s) => isTTY ? `\x1b[36m${s}\x1b[0m` : s,
+    dim: (s) => isTTY ? `\x1b[2m${s}\x1b[0m` : s,
+};
+function log(msg) { process.stdout.write(msg + "\n"); }
+async function waitForLocalTask(taskId) {
+    const task = getTask(taskId);
+    if (!task)
+        return { status: "missing" };
+    const latestTerminalEvent = [...task.events]
+        .reverse()
+        .find((event) => event.type === "done" || event.type === "error");
+    if (task.status !== "running") {
+        return {
+            status: task.status === "error" ? "error" : "done",
+            message: latestTerminalEvent?.message,
+        };
+    }
+    return new Promise((resolve) => {
+        let settled = false;
+        let renderedProgress = false;
+        let unsubscribe = null;
+        const finish = (status, message) => {
+            if (settled)
+                return;
+            settled = true;
+            if (renderedProgress)
+                process.stdout.write("\n");
+            unsubscribe?.();
+            resolve({ status, message });
+        };
+        unsubscribe = subscribeTask(taskId, (event) => {
+            if (settled)
+                return;
+            if (event.type === "log") {
+                if (event.message.trim())
+                    log(c.dim(`  ${event.message}`));
+                return;
+            }
+            if (event.type === "progress") {
+                renderedProgress = true;
+                const progress = typeof event.progress === "number"
+                    ? ` ${c.dim(`[${String(event.progress).padStart(3)}%]`)}`
+                    : "";
+                process.stdout.write(`\r  ${event.message}${progress}   `);
+                return;
+            }
+            if (event.type === "done") {
+                finish("done", event.message);
+                return;
+            }
+            finish("error", event.message);
+        });
+        if (!unsubscribe)
+            finish("missing");
+    });
+}
+async function runManagedAppTask(starter, successMessage) {
+    const started = starter();
+    if (!started.ok) {
+        log(c.red(`  ✗  ${started.error || "Task failed"}`));
+        process.exitCode = 1;
+        return;
+    }
+    if (started.taskId) {
+        const result = await waitForLocalTask(started.taskId);
+        if (result.status === "error") {
+            log(c.red(`  ✗  ${result.message || "Task failed"}`));
+            process.exitCode = 1;
+            return;
+        }
+    }
+    log(c.green(`  ✓  ${successMessage}`));
+}
+function readPassword(prompt) {
+    return new Promise((resolve, reject) => {
+        process.stdout.write(prompt);
+        if (process.stdin.isTTY) {
+            process.stdin.setRawMode(true);
+            process.stdin.resume();
+            let input = "";
+            const onData = (buf) => {
+                const char = buf.toString("utf-8");
+                if (char === "\r" || char === "\n") {
+                    process.stdin.setRawMode(false);
+                    process.stdin.pause();
+                    process.stdin.off("data", onData);
+                    process.stdout.write("\n");
+                    resolve(input);
+                }
+                else if (char === "\u0003") {
+                    process.stdin.setRawMode(false);
+                    process.stdout.write("\n");
+                    reject(new Error("Interrupted"));
+                }
+                else if (char === "\u007f" || char === "\b") {
+                    if (input.length > 0)
+                        input = input.slice(0, -1);
+                }
+                else if (char >= " ") {
+                    input += char;
+                }
+            };
+            process.stdin.on("data", onData);
+            return;
+        }
+        let input = "";
+        process.stdin.resume();
+        process.stdin.setEncoding("utf-8");
+        const onData = (chunk) => {
+            const nl = chunk.indexOf("\n");
+            if (nl >= 0) {
+                input += chunk.slice(0, nl);
+                process.stdin.off("data", onData);
+                process.stdin.pause();
+                resolve(input.replace(/\r$/, "").trim());
+            }
+            else {
+                input += chunk;
+            }
+        };
+        process.stdin.on("data", onData);
+    });
+}
+function isSudoPasswordError(message) {
+    return /sudo 密码|请输入 sudo 密码|password required/i.test(message);
+}
+function getCliSudoState(args) {
+    const flagValue = parseFlag(args, "--sudo-password", "");
+    const flagPassword = typeof flagValue === "string" ? flagValue.trim() : "";
+    const envPassword = process.env.JISHUSHELL_SUDO_PASSWORD?.trim() ?? "";
+    return {
+        password: flagPassword || envPassword,
+        prompted: false,
+    };
+}
+async function promptForCliSudoPassword(state) {
+    if (state.prompted || !process.stdin.isTTY)
+        return false;
+    state.prompted = true;
+    const password = (await readPassword("  sudo 密码: ")).trim();
+    if (!password)
+        return false;
+    state.password = password;
+    return true;
+}
+function formatSudoHint(message, state) {
+    if (isSudoPasswordError(message) && !state.password && !process.stdin.isTTY) {
+        return `${message}；可通过 --sudo-password 或环境变量 JISHUSHELL_SUDO_PASSWORD 提供 sudo 密码。`;
+    }
+    return message;
+}
+async function runManagedUninstallTask(starter, successMessage, sudoState) {
+    while (true) {
+        const started = sudoState.password
+            ? starter({ sudoPassword: sudoState.password })
+            : starter();
+        if (!started.ok) {
+            const message = started.error || "Task failed";
+            if (isSudoPasswordError(message) && await promptForCliSudoPassword(sudoState)) {
+                continue;
+            }
+            log(c.red(`  ✗  ${formatSudoHint(message, sudoState)}`));
+            process.exitCode = 1;
+            return;
+        }
+        if (started.taskId) {
+            const result = await waitForLocalTask(started.taskId);
+            if (result.status === "error") {
+                const message = result.message || "Task failed";
+                if (isSudoPasswordError(message) && await promptForCliSudoPassword(sudoState)) {
+                    continue;
+                }
+                log(c.red(`  ✗  ${formatSudoHint(message, sudoState)}`));
+                process.exitCode = 1;
+                return;
+            }
+        }
+        log(c.green(`  ✓  ${successMessage}`));
+        return;
+    }
+}
+function rewriteInstalledAppYaml(yamlText, sourceId, targetId) {
+    const homeDir = process.env.HOME ?? "";
+    return yamlText
+        .split(`~/.jishushell/apps/${sourceId}`).join(`~/.jishushell/apps/${targetId}`)
+        .split(`$HOME/.jishushell/apps/${sourceId}`).join(`$HOME/.jishushell/apps/${targetId}`)
+        .split(`${homeDir}/.jishushell/apps/${sourceId}`).join(`${homeDir}/.jishushell/apps/${targetId}`);
+}
+function healthTargetsForTask(task) {
+    if (!task?.health)
+        return [];
+    const targets = [];
+    if (task.health.http) {
+        targets.push({
+            method: "http",
+            port: task.health.http.port,
+            path: task.health.http.path,
+        });
+    }
+    return targets;
+}
+function normalizeHealthStatus(status, methods) {
+    if (methods.length === 0)
+        return "none";
+    const normalized = String(status ?? "unknown").toLowerCase();
+    if (["success", "passing", "healthy"].includes(normalized))
+        return "healthy";
+    if (["failure", "critical", "warning", "unhealthy"].includes(normalized))
+        return "unhealthy";
+    if (!normalized || normalized === "pending")
+        return "unknown";
+    return normalized;
+}
+function fallbackTaskState(appStatus) {
+    if (appStatus === "stopped")
+        return "stopped";
+    if (appStatus === "pending")
+        return "pending";
+    return "unknown";
+}
+function resolveProvidePort(spec, provide) {
+    if (typeof provide?.port === "number")
+        return provide.port;
+    const serviceTask = spec.tasks.find((task) => (task.role ?? "service") === "service");
+    return serviceTask?.ports?.[0]?.port;
+}
+function provideAddress(port, path) {
+    if (typeof port !== "number")
+        return undefined;
+    const normalizedPath = path ? (path.startsWith("/") ? path : `/${path}`) : "";
+    return `127.0.0.1:${port}${normalizedPath}`;
+}
+function describeHealthTargets(targets) {
+    return targets
+        .map((target) => `${target.method}${typeof target.port === "number" ? `:${target.port}` : ""}`)
+        .join(",");
+}
+function enrichStatusForCli(status, spec) {
+    const taskSpecs = new Map((spec?.tasks ?? []).map((task) => [task.name, task]));
+    const taskNames = new Set([
+        ...taskSpecs.keys(),
+        ...Object.keys(status.tasks ?? {}),
+    ]);
+    const tasks = {};
+    for (const taskName of taskNames) {
+        const taskSpec = taskSpecs.get(taskName);
+        const runtimeTask = status.tasks?.[taskName];
+        const targets = healthTargetsForTask(taskSpec);
+        const methods = targets.map((target) => target.method);
+        const checks = (runtimeTask?.health_checks ?? []).map((check, index) => {
+            const target = targets[index] ?? targets[0] ?? { method: "unknown" };
+            return {
+                name: check.name,
+                method: target.method,
+                ...(typeof target.port === "number" ? { port: target.port } : {}),
+                ...(target.path ? { path: target.path } : {}),
+                status: normalizeHealthStatus(check.status, methods),
+            };
+        });
+        tasks[taskName] = {
+            state: runtimeTask?.state ?? fallbackTaskState(status.status),
+            restarts: runtimeTask?.restarts ?? 0,
+            ...(runtimeTask?.started_at ? { started_at: runtimeTask.started_at } : {}),
+            health: {
+                methods,
+                status: normalizeHealthStatus(runtimeTask?.health_status, methods),
+                targets,
+                checks,
+            },
+        };
+    }
+    const provides = (spec?.provides ?? []).map((provide) => {
+        const port = resolveProvidePort(spec, provide);
+        return {
+            capability: provide.capability,
+            ...(typeof port === "number" ? { port } : {}),
+            ...(provide.path ? { path: provide.path } : {}),
+            ...(provide.description ? { description: provide.description } : {}),
+            ...(provideAddress(port, provide.path) ? { address: provideAddress(port, provide.path) } : {}),
+        };
+    });
+    return { tasks, provides };
+}
+function colorTaskState(state) {
+    if (state === "running")
+        return c.green(state);
+    if (state === "pending")
+        return c.yellow(state);
+    if (state === "dead" || state === "failed")
+        return c.red(state);
+    return c.dim(state);
+}
+function colorHealthState(state) {
+    if (state === "healthy")
+        return c.green(state);
+    if (state === "unhealthy")
+        return c.red(state);
+    if (state === "unknown")
+        return c.yellow(state);
+    return c.dim(state);
+}
+function parseRemoteYamlUrl(value) {
+    try {
+        const url = new URL(value);
+        if (url.protocol === "https:")
+            return url;
+        if (url.protocol === "http:") {
+            throw new Error("Only HTTPS app spec URLs are supported");
+        }
+        return null;
+    }
+    catch (e) {
+        if (e instanceof TypeError)
+            return null;
+        throw e;
+    }
+}
+async function loadInstallYaml(source) {
+    const remoteUrl = parseRemoteYamlUrl(source);
+    if (remoteUrl) {
+        let resp;
+        try {
+            resp = await fetch(remoteUrl, { signal: AbortSignal.timeout(30_000) });
+        }
+        catch (e) {
+            throw new Error(`Failed to download app YAML: ${e.message}`);
+        }
+        if (!resp.ok) {
+            throw new Error(`Failed to download app YAML: HTTP ${resp.status}`);
+        }
+        const body = await resp.text();
+        if (!body.trim()) {
+            throw new Error(`Downloaded app YAML is empty: ${remoteUrl}`);
+        }
+        return body;
+    }
+    if (!existsSync(source)) {
+        throw new Error(`File not found: ${source}`);
+    }
+    return readFileSync(source, "utf-8");
+}
+// ── Command implementations ───────────────────────────────────────────────
+async function cmdList(args) {
+    ensureNomadToken();
+    const items = await loadManagedListEntries();
+    if (args.includes("--json")) {
+        console.log(JSON.stringify(items, null, 2));
+        return;
+    }
+    printManagedList("Managed Apps / Instances", items, c, log);
+}
+async function cmdShow(id) {
+    const { getApp, getInstance } = await import("../services/app/app-manager.js");
+    const app = getApp(id);
+    if (app) {
+        console.log(JSON.stringify(app, null, 2));
+        return;
+    }
+    const instance = getInstance(id);
+    if (!instance) {
+        log(c.red(`  ✗  App/instance "${id}" not found.`));
+        process.exitCode = 1;
+        return;
+    }
+    console.log(JSON.stringify(instance, null, 2));
+}
+async function cmdInstall(yamlPath, requestedAppId) {
+    const yamlText = await loadInstallYaml(yamlPath);
+    const { installApp } = await import("../services/app/app-manager.js");
+    const result = await installApp(yamlText, requestedAppId);
+    const installModeLabel = result.manifest.install_mode === "instance-dir" ? "instance" : "app";
+    log(c.green(`  ✓  Installed: ${result.manifest.id}  (${result.spec.name || ""} v${result.spec.version || "?"}, ${installModeLabel})`));
+}
+async function cmdProvides(args) {
+    const { listProvidedCapabilities } = await import("../services/app/app-manager.js");
+    const provides = listProvidedCapabilities();
+    if (args.includes("--json")) {
+        console.log(JSON.stringify(provides, null, 2));
+        return;
+    }
+    log("");
+    log(c.bold("  App Provides"));
+    log(c.dim("  ─────────────────────────────────────────────────────"));
+    if (provides.length === 0) {
+        log(c.dim("  (no app capabilities declared)"));
+        log("");
+        return;
+    }
+    const grouped = new Map();
+    for (const provide of provides) {
+        const items = grouped.get(provide.appId) ?? [];
+        items.push(provide);
+        grouped.set(provide.appId, items);
+    }
+    for (const [appId, items] of grouped.entries()) {
+        log(`  ${c.cyan(appId)}`);
+        for (const provide of items) {
+            const endpoint = provide.registeredAddress ?? provide.address ?? "-";
+            const registration = provide.registered
+                ? c.green("registered")
+                : c.dim("declared");
+            log(`    ${provide.capability.padEnd(24)} ${c.cyan(endpoint)}  ${registration}${provide.description ? `  ${c.dim(provide.description)}` : ""}`);
+        }
+    }
+    log("");
+}
+async function cmdUninstall(id, args = []) {
+    const { uninstallAppTask, getApp, getInstance } = await import("../services/app/app-manager.js");
+    if (getApp(id)) {
+        await runManagedUninstallTask((exec) => exec ? uninstallAppTask(id, exec) : uninstallAppTask(id), `Uninstalled: ${id}`, getCliSudoState(args));
+        return;
+    }
+    if (getInstance(id)) {
+        const { deleteInstance } = await import("../services/instance-manager.js");
+        const deleteResult = await deleteInstance(id);
+        if (!deleteResult.ok) {
+            throw new Error(`Failed to uninstall instance '${id}'`);
+        }
+        log(c.green(`  ✓  Uninstalled: ${id}`));
+        return;
+    }
+    log(c.red(`  ✗  App/instance "${id}" not found.`));
+    process.exitCode = 1;
+}
+async function cmdUninstallAll(args = []) {
+    const items = await loadManagedListEntries();
+    if (items.length === 0) {
+        log(c.dim("  (no managed apps or instances to uninstall)"));
+        return;
+    }
+    const { uninstallAppTask } = await import("../services/app/app-manager.js");
+    const { deleteInstance } = await import("../services/instance-manager.js");
+    const errors = [];
+    const sudoState = getCliSudoState(args);
+    for (const item of items) {
+        try {
+            if (item.install_mode === "legacy-instance") {
+                const deleteResult = await deleteInstance(item.id);
+                if (!deleteResult.ok) {
+                    throw new Error(`Failed to uninstall instance '${item.id}'`);
+                }
+            }
+            else {
+                const started = sudoState.password
+                    ? uninstallAppTask(item.id, { sudoPassword: sudoState.password })
+                    : uninstallAppTask(item.id);
+                if (!started.ok) {
+                    const startedMessage = started.error || `Failed to uninstall '${item.id}'`;
+                    if (isSudoPasswordError(startedMessage) && await promptForCliSudoPassword(sudoState)) {
+                        const retried = uninstallAppTask(item.id, { sudoPassword: sudoState.password });
+                        if (!retried.ok) {
+                            throw new Error(formatSudoHint(retried.error || `Failed to uninstall '${item.id}'`, sudoState));
+                        }
+                        const retriedResult = retried.taskId ? await waitForLocalTask(retried.taskId) : { status: "done" };
+                        if (retriedResult.status === "error") {
+                            throw new Error(formatSudoHint(retriedResult.message || `Failed to uninstall '${item.id}'`, sudoState));
+                        }
+                        log(c.green(`  ✓  Uninstalled: ${item.id}`));
+                        continue;
+                    }
+                    throw new Error(formatSudoHint(startedMessage, sudoState));
+                }
+                const taskResult = started.taskId ? await waitForLocalTask(started.taskId) : { status: "done" };
+                if (taskResult.status === "error") {
+                    const taskMessage = taskResult.message || `Failed to uninstall '${item.id}'`;
+                    if (isSudoPasswordError(taskMessage) && await promptForCliSudoPassword(sudoState)) {
+                        const retried = uninstallAppTask(item.id, { sudoPassword: sudoState.password });
+                        if (!retried.ok) {
+                            throw new Error(formatSudoHint(retried.error || `Failed to uninstall '${item.id}'`, sudoState));
+                        }
+                        const retriedResult = retried.taskId ? await waitForLocalTask(retried.taskId) : { status: "done" };
+                        if (retriedResult.status === "error") {
+                            throw new Error(formatSudoHint(retriedResult.message || `Failed to uninstall '${item.id}'`, sudoState));
+                        }
+                        log(c.green(`  ✓  Uninstalled: ${item.id}`));
+                        continue;
+                    }
+                    throw new Error(formatSudoHint(taskMessage, sudoState));
+                }
+            }
+            log(c.green(`  ✓  Uninstalled: ${item.id}`));
+        }
+        catch (err) {
+            const message = err?.message || `Failed to uninstall '${item.id}'`;
+            errors.push(`${item.id}: ${message}`);
+            log(c.red(`  ✗  ${item.id}: ${message}`));
+        }
+    }
+    if (errors.length > 0) {
+        process.exitCode = 1;
+    }
+}
+async function cmdCreateInstance(appId, instanceId, name) {
+    const { getApp, installApp, resolveRequires, updateInstance } = await import("../services/app/app-manager.js");
+    const appData = getApp(appId);
+    if (!appData) {
+        log(c.red(`  ✗  App "${appId}" not found.`));
+        process.exitCode = 1;
+        return;
+    }
+    let resolvedEnv = {};
+    try {
+        resolvedEnv = resolveRequires(appData.spec);
+    }
+    catch (e) {
+        log(c.red(`  ✗  ${e.message}`));
+        process.exitCode = 1;
+        return;
+    }
+    const specWithEnv = Object.keys(resolvedEnv).length > 0
+        ? {
+            ...appData.spec,
+            app_id: appData.manifest.id,
+            tasks: appData.spec.tasks.map((t) => t.role === "service" ? { ...t, env: { ...t.env, ...resolvedEnv } } : t),
+        }
+        : { ...appData.spec, app_id: appData.manifest.id };
+    const rawYaml = rewriteInstalledAppYaml(stringify({
+        ...specWithEnv,
+        name,
+    }), appData.manifest.id, instanceId);
+    await installApp(rawYaml, instanceId, {
+        bootstrap: {
+            name,
+            description: "",
+        },
+    });
+    updateInstance(instanceId, name, "");
+    log(c.green(`  ✓  Created application "${instanceId}" from app "${appId}"`));
+}
+async function cmdCopy(sourceId) {
+    const { copyApp } = await import("../services/app/app-manager.js");
+    const result = await copyApp(sourceId);
+    log(c.green(`  ✓  Copied ${sourceId}  →  ${result.manifest.id}`));
+}
+async function cmdStart(appId) {
+    ensureNomadToken();
+    const { getApp, startAppTask } = await import("../services/app/app-manager.js");
+    const app = getApp(appId);
+    if (app) {
+        await runManagedAppTask(() => startAppTask(appId), `Started: ${app.spec.name || readInstanceMeta(appId)?.name || appId}`);
+        return;
+    }
+    const result = await startNomadJobInstance(appId);
+    if (result.ok) {
+        log(c.green(`  ✓  Started: ${readInstanceMeta(appId)?.name || appId}`));
+        return;
+    }
+    log(c.red(`  ✗  ${result.error || "Start failed"}`));
+    process.exitCode = 1;
+}
+async function cmdStop(appId, purge) {
+    ensureNomadToken();
+    const { getApp, stopAppTask } = await import("../services/app/app-manager.js");
+    const app = getApp(appId);
+    if (app) {
+        await runManagedAppTask(() => stopAppTask(appId, purge), `Stopped: ${app.spec.name || readInstanceMeta(appId)?.name || appId}${purge ? " (purged)" : ""}`);
+        return;
+    }
+    const result = await stopNomadJobInstance(appId, purge);
+    if (result.ok) {
+        log(c.green(`  ✓  Stopped: ${readInstanceMeta(appId)?.name || appId}${purge ? " (purged)" : ""}`));
+        return;
+    }
+    log(c.red(`  ✗  ${result.error || "Stop failed"}`));
+    process.exitCode = 1;
+}
+async function cmdRestart(appId) {
+    ensureNomadToken();
+    const { getApp, restartAppTask } = await import("../services/app/app-manager.js");
+    const app = getApp(appId);
+    if (app) {
+        await runManagedAppTask(() => restartAppTask(appId), `Restarted: ${app.spec.name || readInstanceMeta(appId)?.name || appId}`);
+        return;
+    }
+    const result = await restartNomadJobInstance(appId);
+    if (result.ok) {
+        log(c.green(`  ✓  Restarted: ${readInstanceMeta(appId)?.name || appId}`));
+        return;
+    }
+    log(c.red(`  ✗  ${result.error || "Restart failed"}`));
+    process.exitCode = 1;
+}
+async function cmdStatus(appId, json) {
+    ensureNomadToken();
+    const { getApp, getAppStatus, getInstance } = await import("../services/app/app-manager.js");
+    const app = getApp(appId);
+    if (!app) {
+        const instance = getInstance(appId);
+        if (!instance) {
+            log(c.red(`  ✗  App/instance "${appId}" not found.`));
+            process.exitCode = 1;
+            return;
+        }
+        const status = await getInstanceStatus(appId);
+        if (json) {
+            console.log(JSON.stringify({ id: appId, name: instance.name, ...status }, null, 2));
+            return;
+        }
+        const upStr = status.uptime ? `${Math.floor(status.uptime / 3600)}h ${Math.floor((status.uptime % 3600) / 60)}m` : "—";
+        log("");
+        log(`  ${c.bold("Job:")} ${c.cyan(instance.name || appId)}  ${c.dim(`(${appId})`)}`);
+        log(`  ${c.bold("Status:")} ${status.status === "running" ? c.green(status.status) : status.status}`);
+        log(`  ${c.bold("Uptime:")} ${upStr}`);
+        if (status.memory_mb)
+            log(`  ${c.bold("Memory:")} ${status.memory_mb} MB`);
+        if (status.cpu_percent !== null)
+            log(`  ${c.bold("CPU:")} ${status.cpu_percent}%`);
+        if (status.pid)
+            log(`  ${c.bold("PID:")} ${status.pid}`);
+        log("");
+        return;
+    }
+    const status = await getAppStatus(appId);
+    const enriched = enrichStatusForCli(status, app.spec);
+    if (json) {
+        console.log(JSON.stringify({ id: appId, ...status, tasks: enriched.tasks, provides: enriched.provides }, null, 2));
+        return;
+    }
+    const stColor = status.status === "running" ? c.green
+        : status.status === "stopped" ? c.dim
+            : status.status === "pending" ? c.yellow
+                : c.red;
+    log("");
+    log(`  ${c.bold("App:")}    ${c.cyan(appId)}`);
+    log(`  ${c.bold("Status:")} ${stColor(status.status)}`);
+    if (status.uptime != null)
+        log(`  ${c.bold("Uptime:")} ${status.uptime}s`);
+    if (status.memory_mb)
+        log(`  ${c.bold("Memory:")} ${status.memory_mb} MB`);
+    if (Object.keys(enriched.tasks).length > 0) {
+        log(`  ${c.bold("Tasks:")}`);
+        for (const [name, t] of Object.entries(enriched.tasks)) {
+            log(`    ${name.padEnd(20)} ${colorTaskState(t.state)}  restarts=${t.restarts}`);
+            if (t.health.methods.length > 0) {
+                log(`      health=${describeHealthTargets(t.health.targets)}  status=${colorHealthState(t.health.status)}`);
+            }
+            else {
+                log(`      health=${c.dim("none")}`);
+            }
+        }
+    }
+    if (enriched.provides.length > 0) {
+        log(`  ${c.bold("Provides:")}`);
+        for (const provide of enriched.provides) {
+            const endpoint = provide.address ?? (typeof provide.port === "number" ? `127.0.0.1:${provide.port}` : "-");
+            log(`    ${provide.capability.padEnd(24)} ${c.cyan(endpoint)}${provide.description ? `  ${c.dim(provide.description)}` : ""}`);
+        }
+    }
+    if (status.error)
+        log(c.red(`  ${status.error}`));
+    log("");
+}
+async function cmdLogs(appId, args) {
+    ensureNomadToken();
+    const { getApp, getAppLogs } = await import("../services/app/app-manager.js");
+    const taskArg = args.find((a) => !a.startsWith("--"));
+    const lines = parseFlag(args, "--lines", 200);
+    const logType = args.includes("--stdout") ? "stdout" : "stderr";
+    const logLines = getApp(appId)
+        ? await getAppLogs(appId, taskArg ?? "", lines, logType)
+        : await getInstanceLogs(appId, lines, logType);
+    if (logLines.length === 0) {
+        log(c.dim("  (no logs)"));
+        return;
+    }
+    process.stdout.write(logLines.join("\n") + "\n");
+}
+async function cmdExec(appId, command) {
+    ensureNomadToken();
+    const { getApp, execInApp } = await import("../services/app/app-manager.js");
+    const result = getApp(appId)
+        ? await execInApp(appId, command)
+        : await execInInstance(appId, command);
+    if (result.stdout)
+        process.stdout.write(result.stdout);
+    if (result.stderr)
+        process.stderr.write(result.stderr);
+    if (result.exitCode !== 0)
+        process.exitCode = result.exitCode ?? 1;
+}
+// ── Entry point ───────────────────────────────────────────────────────────
+export async function run(rest) {
+    const appCmd = rest[0];
+    try {
+        if (appCmd === "list") {
+            await cmdList(rest.slice(1));
+        }
+        else if (appCmd === "provides") {
+            await cmdProvides(rest.slice(1));
+        }
+        else if (appCmd === "show" && rest[1]) {
+            await cmdShow(rest[1]);
+        }
+        else if (appCmd === "install" && rest[1]) {
+            await cmdInstall(rest[1], rest[2]);
+        }
+        else if (appCmd === "uninstall" && rest[1] === "--all") {
+            await cmdUninstallAll(rest.slice(2));
+        }
+        else if (appCmd === "uninstall" && rest[1]) {
+            await cmdUninstall(rest[1], rest.slice(2));
+        }
+        else if (appCmd === "create-instance" && rest[1]) {
+            const appId = rest[1];
+            const instanceId = rest[2];
+            const name = rest[3] || instanceId;
+            if (!instanceId) {
+                console.error("Usage: jishushell app create-instance <app-id> <instance-id> [name]");
+                process.exit(1);
+            }
+            await cmdCreateInstance(appId, instanceId, name);
+        }
+        else if (appCmd === "copy" && rest[1]) {
+            await cmdCopy(rest[1]);
+        }
+        else if (appCmd === "start" && rest[1]) {
+            await cmdStart(rest[1]);
+        }
+        else if (appCmd === "stop" && rest[1]) {
+            await cmdStop(rest[1], rest.includes("--purge"));
+        }
+        else if (appCmd === "restart" && rest[1]) {
+            await cmdRestart(rest[1]);
+        }
+        else if (appCmd === "status" && rest[1]) {
+            await cmdStatus(rest[1], rest.includes("--json"));
+        }
+        else if (appCmd === "logs" && rest[1]) {
+            await cmdLogs(rest[1], rest.slice(2));
+        }
+        else if (appCmd === "exec" && rest[1]) {
+            const dashDash = rest.indexOf("--");
+            const execCmd = dashDash >= 0 ? rest.slice(dashDash + 1) : [];
+            if (execCmd.length === 0) {
+                console.error("Usage: jishushell app exec <app-id> -- <command...>");
+                process.exit(1);
+            }
+            await cmdExec(rest[1], execCmd);
+        }
+        else if (appCmd === "help" || appCmd === "--help" || appCmd === "-h") {
+            printHelp();
+        }
+        else {
+            printHelp();
+            if (appCmd)
+                process.exit(1);
+        }
+    }
+    catch (err) {
+        log(c.red(`  ✗  ${err.message}`));
+        process.exitCode = 1;
+    }
+}
+export async function dispatch(argv) {
+    if (argv[0] !== "app")
+        return false;
+    await run(argv.slice(1));
+    return true;
+}
+export function brief() {
+    return "  app <install|list|provides|show|uninstall|copy|start|stop|restart|status|logs|exec>  App/实例统一管理";
+}
+export function printHelp() {
+    console.log(`
+Usage: jishushell app <command> [options]
+
+Commands:
+  list [--json]                                     列出统一受管列表（apps 下已安装应用 + instances 下遗留实例）
+  provides [--json]                                 列出已安装 App 声明/注册的能力
+  show <id>                                         查看 App 或实例详情（JSON）
+  install <yaml-file|https-url> [app-id]            从本地或 HTTPS YAML 安装 App，可选指定安装 id
+  uninstall <app-id> [--sudo-password <password>]   卸载单个 App 或实例（停止 + 删除目录）
+  uninstall --all [--sudo-password <password>]      卸载全部 App 与实例
+  create-instance <app-id> <inst-id> [name]         从 App 创建实例（Agent 通道由 spec.agentType 决定）
+  copy <app-id>                                     复制 App 实例（singleInstance 不可 copy）
+  start <id>                                        启动 App 或实例
+  stop <id> [--purge]                               停止 App 或实例（--purge 同时清除 Nomad job）
+  restart <id>                                      重启 App 或实例
+  status <id> [--json]                              查看 App 或实例状态
+  logs <id> [<task>] [--lines N] [--stdout]         查看日志（默认 stderr）
+  exec <id> -- <cmd...>                             在 App 或实例内执行命令
+  help                                              显示此帮助
+
+Examples:
+  jishushell app install ./apps/ollama-with-hollama-binary.yaml
+  jishushell app install ./apps/ollama-with-hollama-binary.yaml ollama-local
+  jishushell app install https://example.com/apps/ollama-with-hollama-binary.yaml
+  jishushell app list
+  jishushell app provides
+  jishushell app copy ollama-1
+  jishushell app start searxng-container
+  jishushell app status ollama
+  jishushell app logs ollama --lines 100
+  jishushell app exec ollama -- ollama list
+  jishushell app stop searxng-container
+  jishushell app uninstall ollama
+  jishushell app uninstall ollama --sudo-password 'your-sudo-password'
+  jishushell app uninstall --all
+`);
+}
+//# sourceMappingURL=app.js.map