@zokizuan/satori-cli 0.1.1

package/dist/format.js

@@ -0,0 +1,100 @@
+export function emitJson(writers, payload) {
+    writers.writeStdout(`${JSON.stringify(payload, null, 2)}\n`);
+}
+export function emitError(writers, token, message) {
+    writers.writeStderr(`${token} ${message}\n`);
+}
+function firstTextContent(result) {
+    const content = result?.content;
+    if (!Array.isArray(content)) {
+        return null;
+    }
+    const firstText = content.find((entry) => entry && entry.type === "text" && typeof entry.text === "string");
+    if (!firstText || typeof firstText.text !== "string") {
+        return null;
+    }
+    return firstText.text;
+}
+export function parseStructuredEnvelope(result) {
+    const text = firstTextContent(result);
+    if (!text) {
+        return null;
+    }
+    try {
+        const parsed = JSON.parse(text);
+        if (!parsed || typeof parsed !== "object") {
+            return null;
+        }
+        const status = parsed.status;
+        if (typeof status !== "string") {
+            return null;
+        }
+        const reason = parsed.reason;
+        const hints = parsed.hints;
+        const hintStatus = hints && typeof hints === "object"
+            ? hints.status
+            : undefined;
+        return {
+            status,
+            reason: typeof reason === "string" ? reason : undefined,
+            hintStatus
+        };
+    }
+    catch {
+        return null;
+    }
+}
+export function inferManageStatusState(result) {
+    const envelope = parseStructuredEnvelope(result);
+    if (envelope) {
+        if (envelope.status === "not_ready" && envelope.reason === "indexing") {
+            return "indexing";
+        }
+        if (envelope.status === "not_ready" && envelope.reason === "requires_reindex") {
+            return "requires_reindex";
+        }
+        if (envelope.status === "requires_reindex") {
+            return "requires_reindex";
+        }
+        if (envelope.status === "blocked" && envelope.reason === "requires_reindex") {
+            return "requires_reindex";
+        }
+        if (envelope.status === "not_indexed") {
+            return "not_indexed";
+        }
+        if (envelope.status === "blocked" && envelope.reason === "not_indexed") {
+            return "not_indexed";
+        }
+        if (envelope.status === "ok") {
+            return "indexed";
+        }
+        if (envelope.status === "error" && envelope.reason === "requires_reindex") {
+            return "requires_reindex";
+        }
+        if (envelope.status === "error" && envelope.reason === "not_indexed") {
+            return "not_indexed";
+        }
+    }
+    const text = firstTextContent(result);
+    if (!text) {
+        return "unknown";
+    }
+    const normalized = text.toLowerCase();
+    if (normalized.includes("currently being indexed") || normalized.includes("currently indexing")) {
+        return "indexing";
+    }
+    if (normalized.includes("fully indexed and ready")) {
+        return "indexed";
+    }
+    if (normalized.includes("indexing failed")) {
+        return "indexfailed";
+    }
+    if (normalized.includes("must be rebuilt") || normalized.includes("incompatible with the current runtime")) {
+        return "requires_reindex";
+    }
+    if (normalized.includes("is not indexed")) {
+        return "not_indexed";
+    }
+    return "unknown";
+}
+//# sourceMappingURL=format.js.map

package/dist/index.d.ts

@@ -0,0 +1,32 @@
+#!/usr/bin/env node
+interface RunCliOptions {
+    writeStdout?: (text: string) => void;
+    writeStderr?: (text: string) => void;
+    stdin?: NodeJS.ReadStream;
+    env?: NodeJS.ProcessEnv;
+    serverCommand?: string;
+    serverArgs?: string[];
+    serverEnv?: Record<string, string>;
+    startupTimeoutMs?: number;
+    callTimeoutMs?: number;
+    cwd?: string;
+    installabilityVerifier?: () => string | Promise<string>;
+    connectSession?: (options: {
+        command: string;
+        args: string[];
+        env: Record<string, string | undefined>;
+        cwd?: string;
+        startupTimeoutMs: number;
+        callTimeoutMs: number;
+        writeStderr: (text: string) => void;
+    }) => Promise<CliSession>;
+}
+interface CliSession {
+    listTools(): Promise<any>;
+    callTool(name: string, args: Record<string, unknown>): Promise<any>;
+    close(): Promise<void>;
+}
+export declare function runCli(argv: string[], options?: RunCliOptions): Promise<number>;
+export declare function isExecutedDirectlyForPaths(moduleUrl: string, entryPath: string | undefined): boolean;
+export {};
+//# sourceMappingURL=index.d.ts.map

package/dist/index.js

@@ -0,0 +1,301 @@
+#!/usr/bin/env node
+import fs from "node:fs";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+import { parseCliArgs, parseWrapperArgumentsFromSchema, resolveRawArguments } from "./args.js";
+import { connectCliMcpSession } from "./client.js";
+import { asCliError, CliError } from "./errors.js";
+import { emitError, emitJson, inferManageStatusState, parseStructuredEnvelope } from "./format.js";
+import { executeInstallCommand } from "./install.js";
+import { verifyManagedPackageInstallability } from "./package-installability.js";
+import { resolveServerEntryPath } from "./resolve-server-entry.js";
+const MANAGE_INDEX_MIN_POLL_TIMEOUT_MS = 10 * 60 * 1000;
+function firstText(result) {
+    const content = result?.content;
+    if (!Array.isArray(content)) {
+        return null;
+    }
+    const entry = content.find((item) => item?.type === "text" && typeof item?.text === "string");
+    return entry?.text || null;
+}
+function readPackageVersion() {
+    try {
+        const currentFile = fileURLToPath(import.meta.url);
+        const packagePath = path.resolve(path.dirname(currentFile), "..", "package.json");
+        const content = fs.readFileSync(packagePath, "utf8");
+        const parsed = JSON.parse(content);
+        if (parsed && typeof parsed.version === "string") {
+            return parsed.version;
+        }
+    }
+    catch {
+        // Best-effort only.
+    }
+    return "unknown";
+}
+function resolveDefaultServerArgs() {
+    const serverEntry = resolveServerEntryPath();
+    if (serverEntry.endsWith(".ts")) {
+        return ["--import", "tsx", serverEntry];
+    }
+    return [serverEntry];
+}
+function buildHelpPayload() {
+    return {
+        usage: "satori-cli <command>",
+        commands: [
+            "install [--client all|codex|claude] [--dry-run]",
+            "uninstall [--client all|codex|claude] [--dry-run]",
+            "tools list",
+            "tool call <toolName> --args-json '<json>'",
+            "tool call <toolName> --args-file <path>",
+            "<toolName> [schema-driven flags]"
+        ],
+        globalFlags: [
+            "--startup-timeout-ms <n>",
+            "--call-timeout-ms <n>",
+            "--format json|text",
+            "--debug"
+        ]
+    };
+}
+function resolveToolSchema(toolsResult, toolName) {
+    const tools = Array.isArray(toolsResult?.tools) ? toolsResult.tools : [];
+    const tool = tools.find((entry) => entry && entry.name === toolName);
+    if (!tool) {
+        throw new CliError("E_USAGE", `Unknown tool '${toolName}'.`, 2);
+    }
+    const schema = tool.inputSchema ?? tool.input_schema;
+    if (!schema || typeof schema !== "object") {
+        throw new CliError("E_SCHEMA_UNSUPPORTED", `${toolName} schema is missing or invalid. Use --args-json/--args-file.`, 2);
+    }
+    return schema;
+}
+function sleep(ms) {
+    return new Promise((resolve) => {
+        const timer = setTimeout(resolve, ms);
+        timer.unref();
+    });
+}
+async function pollManageIndexUntilTerminal(pathArg, session, timeoutMs) {
+    const startedAt = Date.now();
+    const pollIntervalMs = 500;
+    while (Date.now() - startedAt < timeoutMs) {
+        await sleep(pollIntervalMs);
+        const statusResult = await session.callTool("manage_index", {
+            action: "status",
+            path: pathArg
+        });
+        const state = inferManageStatusState(statusResult);
+        if (state === "indexing" || state === "unknown") {
+            continue;
+        }
+        return { result: statusResult, state };
+    }
+    throw new CliError("E_CALL_TIMEOUT", `Timed out after ${timeoutMs}ms while waiting for manage_index status.`, 3);
+}
+function shouldWaitManageIndex(toolName, args) {
+    if (toolName !== "manage_index") {
+        return false;
+    }
+    const action = args.action;
+    if (action !== "create" && action !== "reindex") {
+        return false;
+    }
+    return typeof args.path === "string" && args.path.length > 0;
+}
+function summarizeEnvelopeError(writers, envelope) {
+    if (!envelope) {
+        return;
+    }
+    const status = envelope.status;
+    const reasonPart = envelope.reason ? ` reason=${envelope.reason}` : "";
+    const statusHintPart = envelope.hintStatus ? ` status_hint=${JSON.stringify(envelope.hintStatus)}` : "";
+    writers.writeStderr(`E_TOOL_ERROR status=${status}${reasonPart}${statusHintPart}\n`);
+}
+function maybeEmitTextSummary(writers, result) {
+    const text = firstText(result);
+    if (text) {
+        writers.writeStderr(`${text}\n`);
+    }
+}
+function evaluateToolResultForError(result, writers) {
+    if (result?.isError === true) {
+        const message = firstText(result) || "tool call failed";
+        writers.writeStderr(`E_TOOL_ERROR ${message}\n`);
+        return 1;
+    }
+    const envelope = parseStructuredEnvelope(result);
+    if (envelope && envelope.status !== "ok") {
+        summarizeEnvelopeError(writers, envelope);
+        return 1;
+    }
+    return null;
+}
+async function invokeTool(toolName, args, session, callTimeoutMs, writers, format) {
+    let result = await session.callTool(toolName, args);
+    let manageWaitState = null;
+    const initialErrorExit = evaluateToolResultForError(result, writers);
+    if (initialErrorExit !== null) {
+        emitJson(writers, result);
+        if (format === "text") {
+            maybeEmitTextSummary(writers, result);
+        }
+        return initialErrorExit;
+    }
+    if (shouldWaitManageIndex(toolName, args)) {
+        const effectiveManagePollTimeoutMs = Math.max(callTimeoutMs, MANAGE_INDEX_MIN_POLL_TIMEOUT_MS);
+        const polled = await pollManageIndexUntilTerminal(args.path, session, effectiveManagePollTimeoutMs);
+        result = polled.result;
+        manageWaitState = polled.state;
+    }
+    emitJson(writers, result);
+    if (format === "text") {
+        maybeEmitTextSummary(writers, result);
+    }
+    const finalErrorExit = evaluateToolResultForError(result, writers);
+    if (finalErrorExit !== null) {
+        return finalErrorExit;
+    }
+    if (manageWaitState === "indexfailed" || manageWaitState === "requires_reindex" || manageWaitState === "not_indexed") {
+        emitError(writers, "E_TOOL_ERROR", `manage_index terminal state=${manageWaitState}`);
+        return 1;
+    }
+    return 0;
+}
+export async function runCli(argv, options = {}) {
+    const writers = {
+        writeStdout: options.writeStdout || ((text) => process.stdout.write(text)),
+        writeStderr: options.writeStderr || ((text) => process.stderr.write(text)),
+    };
+    const effectiveEnv = options.env || process.env;
+    let parsedFormat = "json";
+    let parsedCommandKind = null;
+    try {
+        const parsed = parseCliArgs(argv);
+        parsedFormat = parsed.globals.format;
+        parsedCommandKind = parsed.command.kind;
+        const startupTimeoutMs = options.startupTimeoutMs ?? parsed.globals.startupTimeoutMs;
+        const callTimeoutMs = options.callTimeoutMs ?? parsed.globals.callTimeoutMs;
+        if (parsed.command.kind === "help") {
+            emitJson(writers, buildHelpPayload());
+            if (parsed.globals.format === "text") {
+                writers.writeStderr("satori-cli help requested.\n");
+            }
+            return 0;
+        }
+        if (parsed.command.kind === "version") {
+            emitJson(writers, {
+                name: "@zokizuan/satori-cli",
+                cli: "satori-cli",
+                version: readPackageVersion(),
+            });
+            if (parsed.globals.format === "text") {
+                writers.writeStderr("satori-cli version shown.\n");
+            }
+            return 0;
+        }
+        if (parsed.command.kind === "install" || parsed.command.kind === "uninstall") {
+            if (parsed.command.kind === "install") {
+                await (options.installabilityVerifier || verifyManagedPackageInstallability)();
+            }
+            const result = executeInstallCommand(parsed.command, {
+                homeDir: effectiveEnv.HOME,
+            });
+            emitJson(writers, result);
+            if (parsed.globals.format === "text") {
+                writers.writeStderr(`satori-cli ${parsed.command.kind} completed for ${parsed.command.client}.\n`);
+            }
+            return 0;
+        }
+        const session = await (options.connectSession || connectCliMcpSession)({
+            command: options.serverCommand || process.execPath,
+            args: options.serverArgs || resolveDefaultServerArgs(),
+            env: {
+                ...effectiveEnv,
+                ...options.serverEnv,
+                SATORI_RUN_MODE: "cli",
+            },
+            cwd: options.cwd,
+            startupTimeoutMs,
+            callTimeoutMs,
+            writeStderr: writers.writeStderr,
+        });
+        try {
+            if (parsed.command.kind === "tools-list") {
+                const result = await session.listTools();
+                emitJson(writers, result);
+                return 0;
+            }
+            if (parsed.command.kind === "tool-call") {
+                const args = await resolveRawArguments(parsed.command.rawArgsMode, {
+                    stdin: options.stdin,
+                    stdinTimeoutMs: callTimeoutMs,
+                });
+                return await invokeTool(parsed.command.toolName, args, session, callTimeoutMs, writers, parsed.globals.format);
+            }
+            const listToolsResult = await session.listTools();
+            const schema = resolveToolSchema(listToolsResult, parsed.command.toolName);
+            const args = parsed.command.rawArgsMode.kind !== "none"
+                ? await resolveRawArguments(parsed.command.rawArgsMode, {
+                    stdin: options.stdin,
+                    stdinTimeoutMs: callTimeoutMs,
+                })
+                : parseWrapperArgumentsFromSchema(parsed.command.toolName, schema, parsed.command.wrapperArgs);
+            return await invokeTool(parsed.command.toolName, args, session, callTimeoutMs, writers, parsed.globals.format);
+        }
+        finally {
+            await session.close();
+        }
+    }
+    catch (error) {
+        const cliError = asCliError(error);
+        if (parsedFormat === "json"
+            && (parsedCommandKind === "tool-call" || parsedCommandKind === "wrapper")) {
+            emitJson(writers, {
+                isError: true,
+                content: [{
+                        type: "text",
+                        text: `${cliError.token} ${cliError.message}`
+                    }],
+                _meta: {
+                    cliErrorToken: cliError.token,
+                    exitCode: cliError.exitCode
+                }
+            });
+        }
+        emitError(writers, cliError.token, cliError.message);
+        return cliError.exitCode;
+    }
+}
+async function main() {
+    const exitCode = await runCli(process.argv.slice(2));
+    process.exit(exitCode);
+}
+function isExecutedDirectly() {
+    return isExecutedDirectlyForPaths(import.meta.url, process.argv[1]);
+}
+export function isExecutedDirectlyForPaths(moduleUrl, entryPath) {
+    if (!entryPath) {
+        return false;
+    }
+    try {
+        const modulePath = fs.realpathSync(fileURLToPath(moduleUrl));
+        const invokedPath = fs.realpathSync(path.resolve(entryPath));
+        return modulePath === invokedPath;
+    }
+    catch {
+        try {
+            const modulePath = path.resolve(fileURLToPath(moduleUrl));
+            const invokedPath = path.resolve(entryPath);
+            return modulePath === invokedPath;
+        }
+        catch {
+            return false;
+        }
+    }
+}
+if (isExecutedDirectly()) {
+    void main();
+}
+//# sourceMappingURL=index.js.map

package/dist/install.d.ts

@@ -0,0 +1,30 @@
+import type { InstallClient } from "./args.js";
+type ClientName = Exclude<InstallClient, "all">;
+export interface InstallCommandInput {
+    kind: "install" | "uninstall";
+    client: InstallClient;
+    dryRun: boolean;
+}
+export interface InstallCommandOptions {
+    homeDir?: string;
+    packageSpecifier?: string;
+    skillAssetRoot?: string;
+}
+export interface ClientInstallResult {
+    client: ClientName;
+    configPath: string;
+    skillsPath: string;
+    configChanged: boolean;
+    skillsChanged: boolean;
+    status: "updated" | "unchanged";
+    dryRun: boolean;
+}
+export interface InstallCommandResult {
+    action: "install" | "uninstall";
+    client: InstallClient;
+    dryRun: boolean;
+    results: ClientInstallResult[];
+}
+export declare function executeInstallCommand(command: InstallCommandInput, options?: InstallCommandOptions): InstallCommandResult;
+export {};
+//# sourceMappingURL=install.d.ts.map