@synap-core/cli 1.1.0 → 1.2.1

package/dist/commands/openclaw.js

@@ -50,10 +50,18 @@ export async function openclawOverview() {
         log.dim(`Version: ${oc.version}`);
     // ── AI provider ─────────────────────────────────────────────────────────
     log.heading("AI Provider");
-    const apiKeyStatus = getAiKeyStatus();
-    if (apiKeyStatus.configured) {
-        log.success(`${apiKeyStatus.provider} key configured`);
-        log.dim(`Model: ${apiKeyStatus.model ?? "default"}`);
+    const aiConfig = readOpenClawAiConfig(oc);
+    const hasAnyKey = !!(aiConfig.anthropicKey || aiConfig.openaiKey || aiConfig.geminiKey);
+    const apiKeyStatus = { configured: hasAnyKey };
+    if (hasAnyKey) {
+        if (aiConfig.anthropicKey)
+            log.success(`Anthropic: ${maskKey(aiConfig.anthropicKey)}`);
+        if (aiConfig.openaiKey)
+            log.success(`OpenAI:    ${maskKey(aiConfig.openaiKey)}`);
+        if (aiConfig.geminiKey)
+            log.success(`Google:    ${maskKey(aiConfig.geminiKey)}`);
+        if (aiConfig.primaryModel)
+            log.dim(`Model:     ${aiConfig.primaryModel}`);
     }
     else {
         log.warn("No AI API key configured — OpenClaw cannot process requests");
@@ -134,37 +142,49 @@ export async function openclawConnect(opts) {
     const gatewayPort = oc.gatewayPort ?? 18789;
     const isDocker = oc.runtime === "docker";
     // OpenClaw MCP is stdio-based — clients run `openclaw mcp serve` as a local process
-    // which connects to the gateway over WebSocket.
-    // For Docker/remote setups the gateway is at ws://localhost:<port> after SSH tunnel.
+    // which connects to the gateway over WebSocket. The gateway token authenticates
+    // the connection — we fetch it from the container so the config is ready to paste.
+    const token = readGatewayToken(oc) ?? undefined;
+    if (!token) {
+        log.warn("Could not read gateway token from OpenClaw.");
+        log.dim("The MCP configs below will require you to add --token manually.");
+        log.dim("Run: synap openclaw token");
+        log.blank();
+    }
     const client = opts.client?.toLowerCase();
     if (!client || client === "claude") {
-        printMcpConfig("Claude Desktop", gatewayPort, isDocker, "claude");
+        printMcpConfig("Claude Desktop", gatewayPort, isDocker, "claude", token);
     }
     if (!client || client === "cursor") {
-        printMcpConfig("Cursor", gatewayPort, isDocker, "cursor");
+        printMcpConfig("Cursor", gatewayPort, isDocker, "cursor", token);
     }
     if (!client || client === "windsurf") {
-        printMcpConfig("Windsurf", gatewayPort, isDocker, "windsurf");
+        printMcpConfig("Windsurf", gatewayPort, isDocker, "windsurf", token);
     }
     if (client && !["claude", "cursor", "windsurf"].includes(client)) {
         log.warn(`Unknown client "${client}". Showing generic config.`);
-        printMcpConfig("MCP Client", gatewayPort, isDocker, "generic");
+        printMcpConfig("MCP Client", gatewayPort, isDocker, "generic", token);
     }
     if (isDocker) {
         log.blank();
         log.info("Remote server? Tunnel the gateway port first:");
-        log.dim("  ssh -N -L 18789:localhost:18789 user@your-server");
-        log.dim("  Then use the configs above (they point to localhost:18789)");
+        log.dim(`  ssh -N -L ${gatewayPort}:localhost:${gatewayPort} user@your-server`);
+        log.dim("  Then use the configs above (they point to localhost)");
         log.blank();
-        log.dim("openclaw must be installed locally: npm i -g openclaw");
+        log.dim("openclaw must be installed locally on the client machine:");
+        log.dim("  npm i -g openclaw");
     }
 }
-function printMcpConfig(label, gatewayPort, isRemote, client) {
+function printMcpConfig(label, gatewayPort, isRemote, client, token) {
     log.heading(label);
     // MCP config: stdio command that connects to the local (or tunneled) gateway
-    const args = isRemote
-        ? ["mcp", "serve", "--url", `ws://localhost:${gatewayPort}`]
-        : ["mcp", "serve"];
+    const args = ["mcp", "serve"];
+    if (isRemote) {
+        args.push("--url", `ws://localhost:${gatewayPort}`);
+    }
+    if (token) {
+        args.push("--token", token);
+    }
     const config = JSON.stringify({ mcpServers: { openclaw: { command: "openclaw", args } } }, null, 2);
     const paths = {
         claude: "macOS: ~/Library/Application Support/Claude/claude_desktop_config.json",
@@ -390,52 +410,68 @@ export async function openclawSetupDomain() {
     log.dim("This takes ~30s the first time.");
     log.blank();
 }
-// ─── Configure: set AI provider key ──────────────────────────────────────────
-export async function openclawConfigure() {
-    banner();
-    log.heading("Configure AI Provider");
-    const deployDir = findSynapDeployDir();
-    // Show current status
-    const current = getAiKeyStatus();
-    if (current.configured) {
-        log.success(`Currently using: ${current.provider}`);
-        log.dim(`Model: ${current.model ?? "default"}`);
-        log.blank();
+export async function openclawConfigure(opts = {}) {
+    const oc = detectOpenClaw();
+    if (!oc.found) {
+        log.error("OpenClaw is not running.");
+        return;
     }
-    const { provider } = await prompts({
-        type: "select",
-        name: "provider",
-        message: "Which AI provider?",
-        choices: [
-            {
-                title: "Anthropic (Claude)",
-                description: "claude-sonnet-4-6 — best quality, recommended",
-                value: "anthropic",
-            },
-            {
-                title: "OpenAI (GPT-4o)",
-                value: "openai",
-            },
-            {
-                title: "Google (Gemini)",
-                value: "google",
-            },
-            {
-                title: "Synap IS (via pod)",
-                description: "Uses your pod AI — no external key needed",
-                value: "synap",
-            },
-        ],
-    });
-    if (!provider)
+    // Verify openclaw binary is actually callable inside the container before
+    // we start writing config. Protects against "container up but openclaw not ready".
+    if (oc.runtime === "docker" && !verifyOpenclawCliReady(oc.containerName ?? "openclaw")) {
+        log.error("OpenClaw container is running, but the openclaw CLI isn't responding.");
+        log.dim("It may still be initializing. Wait 30s and try again, or run: synap openclaw doctor");
         return;
-    if (provider === "synap") {
-        log.blank();
-        log.info("Synap IS uses your pod's AI subscription.");
-        log.dim("Make sure IS is provisioned: synap finish");
-        log.dim("Then OpenClaw will use your pod URL as the AI endpoint.");
+    }
+    // ── Show current config ─────────────────────────────────────────────────
+    if (opts.show) {
+        log.heading("OpenClaw AI Config");
+        const current = readOpenClawAiConfig(oc);
+        if (current.anthropicKey)
+            log.success(`Anthropic: ${maskKey(current.anthropicKey)}`);
+        if (current.openaiKey)
+            log.success(`OpenAI:    ${maskKey(current.openaiKey)}`);
+        if (current.geminiKey)
+            log.success(`Google:    ${maskKey(current.geminiKey)}`);
+        if (current.primaryModel)
+            log.info(`Model:     ${current.primaryModel}`);
+        if (!current.anthropicKey && !current.openaiKey && !current.geminiKey) {
+            log.warn("No AI provider key configured");
+        }
         return;
     }
+    // ── Interactive (delegate to OpenClaw's own wizard) ──────────────────────
+    if (opts.interactive) {
+        handoffToOpenClawWizard(oc);
+        return;
+    }
+    banner();
+    log.heading("Configure AI Provider");
+    // ── Scripted path (--provider + --key) ───────────────────────────────────
+    let provider = opts.provider;
+    let apiKey = opts.key;
+    let model = opts.model;
+    if (!provider) {
+        const pick = await prompts({
+            type: "select",
+            name: "provider",
+            message: "Which AI provider?",
+            choices: [
+                { title: "Anthropic (Claude)", description: "recommended", value: "anthropic" },
+                { title: "OpenAI (GPT-4o)", value: "openai" },
+                { title: "Google (Gemini)", value: "google" },
+                { title: "Run OpenClaw's own wizard", description: "interactive", value: "wizard" },
+            ],
+        });
+        if (!pick.provider)
+            return;
+        // Inline handoff — don't recurse, we already have `oc` in scope
+        if (pick.provider === "wizard") {
+            handoffToOpenClawWizard(oc);
+            return;
+        }
+        provider = pick.provider;
+    }
     const envKey = provider === "anthropic"
         ? "ANTHROPIC_API_KEY"
         : provider === "openai"
@@ -446,66 +482,125 @@ export async function openclawConfigure() {
         : provider === "openai"
             ? "openai/gpt-4o"
             : "google/gemini-2.0-flash";
-    const { apiKey } = await prompts({
-        type: "password",
-        name: "apiKey",
-        message: `${envKey}:`,
-    });
-    if (!apiKey)
+    if (!apiKey) {
+        const res = await prompts({ type: "password", name: "apiKey", message: `${envKey}:` });
+        if (!res.apiKey)
+            return;
+        apiKey = res.apiKey;
+    }
+    if (!model) {
+        const res = await prompts({
+            type: "text",
+            name: "model",
+            message: "Model:",
+            initial: modelDefault,
+        });
+        if (!res.model)
+            return;
+        model = res.model;
+    }
+    // Final narrowing — both are guaranteed strings by this point
+    const finalKey = apiKey;
+    const finalModel = model;
+    // ── Write via OpenClaw's own config system ──────────────────────────────
+    const containerName = oc.containerName ?? "openclaw";
+    // Step 1: API key — MUST succeed
+    const keySpinner = ora(`Setting env.${envKey}...`).start();
+    const keyResult = runOpenClawConfigSet(containerName, `env.${envKey}`, finalKey);
+    if (!keyResult.ok) {
+        keySpinner.fail(`Failed to set env.${envKey}`);
+        log.dim(keyResult.stderr || keyResult.error || "(no output)");
+        log.dim("Diagnose: synap openclaw doctor");
         return;
-    const { model } = await prompts({
-        type: "text",
-        name: "model",
-        message: "Model (leave blank for default):",
-        initial: modelDefault,
-    });
-    if (deployDir) {
-        // Write to .env file
-        const envFile = `${deployDir}/.env`;
-        writeEnvVar(envFile, envKey, apiKey);
-        if (model && model !== modelDefault) {
-            writeEnvVar(envFile, "OPENCLAW_MODEL", model);
-        }
-        else {
-            writeEnvVar(envFile, "OPENCLAW_MODEL", modelDefault);
+    }
+    keySpinner.succeed(`Set env.${envKey}`);
+    // Step 2: Model — non-fatal (schema path may differ across OpenClaw versions)
+    const modelSpinner = ora(`Setting default model to ${finalModel}...`).start();
+    const modelPaths = [
+        "agents.defaults.model.primary",
+        "models.default",
+        "agent.model",
+    ];
+    let modelSet = false;
+    let modelError = "";
+    for (const modelPath of modelPaths) {
+        const r = runOpenClawConfigSet(containerName, modelPath, finalModel);
+        if (r.ok) {
+            modelSpinner.succeed(`Set ${modelPath} = ${finalModel}`);
+            modelSet = true;
+            break;
         }
-        log.blank();
-        log.success(`${envKey} written to ${deployDir}/.env`);
-        // Restart container to pick up new env vars
-        const oc = detectOpenClaw();
-        const containerName = oc.containerName ?? "openclaw";
-        const { doRestart } = await prompts({
-            type: "confirm",
-            name: "doRestart",
-            message: `Restart ${containerName} to apply?`,
-            initial: true,
+        modelError = r.stderr || r.error || modelError;
+    }
+    if (!modelSet) {
+        modelSpinner.warn(`Couldn't set model automatically — set it manually`);
+        log.dim(`Tried: ${modelPaths.join(", ")}`);
+        if (modelError)
+            log.dim(`Last error: ${modelError.split("\n")[0]}`);
+        log.dim(`Run: docker exec -it ${containerName} openclaw configure`);
+    }
+    // ── Restart to apply ─────────────────────────────────────────────────────
+    log.info("Restarting OpenClaw to apply...");
+    try {
+        execSync(`docker restart ${containerName}`, { stdio: "pipe", timeout: 30000 });
+        log.success("Restarted — give it ~30s to come back up");
+        log.dim("Check: synap openclaw");
+    }
+    catch {
+        log.warn("Restart failed — run manually: docker restart openclaw");
+    }
+    log.blank();
+}
+// ─── Configure helpers ───────────────────────────────────────────────────────
+function verifyOpenclawCliReady(containerName) {
+    try {
+        execSync(`docker exec ${containerName} openclaw --version`, {
+            stdio: "pipe",
+            timeout: 8000,
         });
-        if (doRestart) {
-            try {
-                log.info(`Restarting ${containerName}...`);
-                execSync(`docker restart ${containerName}`, { stdio: "pipe", timeout: 30000 });
-                log.success("Restarted. Give it 30s to come back up.");
-                log.dim(`Check: synap openclaw`);
-            }
-            catch {
-                log.warn("Restart failed — restart manually:");
-                log.dim(`  docker restart ${containerName}`);
-            }
-        }
+        return true;
     }
-    else {
-        // No deploy dir — show env export instructions
-        log.blank();
-        log.warn("Could not find deploy directory. Set the key manually:");
-        log.blank();
-        console.log(chalk.cyan(`  export ${envKey}="${apiKey}"`));
-        if (model) {
-            console.log(chalk.cyan(`  export OPENCLAW_MODEL="${model}"`));
-        }
-        log.blank();
-        log.dim("Or add to your pod .env file, then: docker restart openclaw");
+    catch {
+        return false;
     }
+}
+function handoffToOpenClawWizard(oc) {
+    if (oc.runtime !== "docker") {
+        log.error("Interactive wizard only works for Docker runtime.");
+        log.dim("For local install, run: openclaw configure");
+        return;
+    }
+    const containerName = oc.containerName ?? "openclaw";
+    log.heading("Handing off to OpenClaw");
+    log.dim(`Running: docker exec -it ${containerName} openclaw configure`);
     log.blank();
+    try {
+        // stdio: inherit passes our TTY through to docker exec.
+        // If we're not on a TTY (e.g. piped input), docker exec -it will fail — catch it.
+        execSync(`docker exec -it ${containerName} openclaw configure`, { stdio: "inherit" });
+    }
+    catch (err) {
+        const msg = err instanceof Error ? err.message : String(err);
+        log.error(`openclaw configure failed: ${msg}`);
+        log.dim(`Run directly: docker exec -it ${containerName} openclaw configure`);
+    }
+}
+function runOpenClawConfigSet(containerName, key, value) {
+    try {
+        // Use shell quoting via JSON.stringify — handles quotes + special chars safely.
+        // stdio: pipe so we can capture stderr on failure.
+        execSync(`docker exec ${containerName} openclaw config set ${key} ${JSON.stringify(value)}`, { stdio: "pipe", timeout: 15000, encoding: "utf-8" });
+        return { ok: true };
+    }
+    catch (err) {
+        const e = err;
+        const stderr = typeof e.stderr === "string" ? e.stderr : e.stderr?.toString("utf-8");
+        return {
+            ok: false,
+            stderr: stderr?.trim(),
+            error: e.message,
+        };
+    }
 }
 // ─── Logs: tail container output ─────────────────────────────────────────────
 export function openclawLogs(opts) {
@@ -528,6 +623,138 @@ export function openclawLogs(opts) {
         log.dim(`Try: docker logs ${containerName} --tail 50`);
     }
 }
+// ─── Token: print the gateway token ──────────────────────────────────────────
+export function openclawToken(opts) {
+    const oc = detectOpenClaw();
+    if (!oc.found) {
+        log.error("OpenClaw is not running.");
+        return;
+    }
+    const token = readGatewayToken(oc);
+    if (!token) {
+        log.error("Could not read gateway token from OpenClaw.");
+        log.dim("Try: synap openclaw doctor");
+        return;
+    }
+    if (opts.for) {
+        // Print a pre-filled MCP client config with the token embedded
+        const client = opts.for.toLowerCase();
+        const gatewayPort = oc.gatewayPort ?? 18789;
+        const config = {
+            mcpServers: {
+                openclaw: {
+                    command: "openclaw",
+                    args: [
+                        "mcp",
+                        "serve",
+                        "--url",
+                        `ws://localhost:${gatewayPort}`,
+                        "--token",
+                        token,
+                    ],
+                },
+            },
+        };
+        const paths = {
+            claude: "~/Library/Application Support/Claude/claude_desktop_config.json",
+            cursor: "~/.cursor/mcp.json",
+            windsurf: "~/.windsurf/mcp.json",
+        };
+        log.heading(client.charAt(0).toUpperCase() + client.slice(1));
+        if (paths[client])
+            log.dim(`Config file: ${paths[client]}`);
+        log.blank();
+        console.log(chalk.cyan(JSON.stringify(config, null, 2)));
+        log.blank();
+        return;
+    }
+    if (opts.copy) {
+        try {
+            const pbcopy = process.platform === "darwin"
+                ? "pbcopy"
+                : process.platform === "linux"
+                    ? "xclip -selection clipboard"
+                    : null;
+            if (pbcopy) {
+                execSync(`echo -n ${JSON.stringify(token)} | ${pbcopy}`, { stdio: "pipe" });
+                log.success("Token copied to clipboard");
+                return;
+            }
+        }
+        catch {
+            // fall through to print
+        }
+    }
+    // Plain print
+    console.log(token);
+}
+function readGatewayToken(oc) {
+    if (!oc.found)
+        return null;
+    if (oc.runtime === "docker") {
+        const containerName = oc.containerName ?? "openclaw";
+        // Try OpenClaw's own config first — works even if token file path changes
+        try {
+            const raw = execSync(`docker exec ${containerName} openclaw config get gateway.token 2>/dev/null`, { encoding: "utf-8", timeout: 5000 }).trim();
+            if (raw && raw !== "undefined" && raw !== "null") {
+                return raw.replace(/^["']|["']$/g, "");
+            }
+        }
+        catch {
+            // fall through
+        }
+        // Fallback: read the token file directly
+        try {
+            const raw = execSync(`docker exec ${containerName} cat /root/.openclaw/gateway.token 2>/dev/null`, { encoding: "utf-8", timeout: 5000 }).trim();
+            return raw || null;
+        }
+        catch {
+            return null;
+        }
+    }
+    // Local install — read from host filesystem
+    try {
+        const tokenPath = `${process.env.HOME}/.openclaw/gateway.token`;
+        if (fs.existsSync(tokenPath)) {
+            return fs.readFileSync(tokenPath, "utf-8").trim();
+        }
+    }
+    catch {
+        // ignore
+    }
+    return null;
+}
+// ─── Doctor: run OpenClaw's own diagnostic ───────────────────────────────────
+export function openclawDoctor(opts) {
+    const oc = detectOpenClaw();
+    if (!oc.found) {
+        log.error("OpenClaw is not running.");
+        return;
+    }
+    const fixFlag = opts.fix ? " --fix" : "";
+    if (oc.runtime === "docker") {
+        const containerName = oc.containerName ?? "openclaw";
+        log.dim(`Running: docker exec ${containerName} openclaw doctor${fixFlag}`);
+        log.blank();
+        try {
+            execSync(`docker exec ${containerName} openclaw doctor${fixFlag}`, {
+                stdio: "inherit",
+                timeout: 60000,
+            });
+        }
+        catch {
+            log.warn("openclaw doctor reported issues or failed");
+        }
+    }
+    else {
+        try {
+            execSync(`openclaw doctor${fixFlag}`, { stdio: "inherit", timeout: 60000 });
+        }
+        catch {
+            log.warn("openclaw doctor reported issues or failed");
+        }
+    }
+}
 // ─── Restart ─────────────────────────────────────────────────────────────────
 export async function openclawRestart() {
     const oc = detectOpenClaw();
@@ -571,54 +798,6 @@ function getOpenClawPublicUrl() {
         return null;
     }
 }
-function getAiKeyStatus() {
-    // Check deploy dir .env first (most accurate for Docker deployments)
-    const deployDir = findSynapDeployDir();
-    if (deployDir) {
-        const envFile = `${deployDir}/.env`;
-        try {
-            const envContent = fs.readFileSync(envFile, "utf-8");
-            const vars = parseEnvFile(envContent);
-            if (vars.ANTHROPIC_API_KEY) {
-                return { configured: true, provider: "Anthropic", model: vars.OPENCLAW_MODEL };
-            }
-            if (vars.OPENAI_API_KEY) {
-                return { configured: true, provider: "OpenAI", model: vars.OPENCLAW_MODEL };
-            }
-            if (vars.GEMINI_API_KEY) {
-                return { configured: true, provider: "Google", model: vars.OPENCLAW_MODEL };
-            }
-        }
-        catch {
-            // unreadable
-        }
-    }
-    // Fallback: check live container env (via docker inspect)
-    const oc = detectOpenClaw();
-    if (oc.runtime === "docker") {
-        try {
-            const containerName = oc.containerName ?? "openclaw";
-            const raw = execSync(`docker inspect --format '{{range .Config.Env}}{{.}}\\n{{end}}' ${containerName} 2>/dev/null`, { encoding: "utf-8", timeout: 5000 });
-            const envLines = raw.split("\\n").filter(Boolean);
-            const env = {};
-            for (const line of envLines) {
-                const idx = line.indexOf("=");
-                if (idx > 0)
-                    env[line.slice(0, idx)] = line.slice(idx + 1);
-            }
-            if (env.ANTHROPIC_API_KEY)
-                return { configured: true, provider: "Anthropic", model: env.OPENCLAW_MODEL };
-            if (env.OPENAI_API_KEY)
-                return { configured: true, provider: "OpenAI", model: env.OPENCLAW_MODEL };
-            if (env.GEMINI_API_KEY)
-                return { configured: true, provider: "Google", model: env.OPENCLAW_MODEL };
-        }
-        catch {
-            // docker not available
-        }
-    }
-    return { configured: false };
-}
 function checkSkillInstalled(oc) {
     if (!oc.found)
         return false;
@@ -652,21 +831,6 @@ function writeEnvVar(envFile, key, value) {
             : content + "\n" + line + "\n";
     fs.writeFileSync(envFile, content, { mode: 0o600 });
 }
-function parseEnvFile(content) {
-    const result = {};
-    for (const line of content.split("\n")) {
-        const trimmed = line.trim();
-        if (!trimmed || trimmed.startsWith("#"))
-            continue;
-        const idx = trimmed.indexOf("=");
-        if (idx > 0) {
-            const key = trimmed.slice(0, idx);
-            const val = trimmed.slice(idx + 1).replace(/^["']|["']$/g, "");
-            result[key] = val;
-        }
-    }
-    return result;
-}
 // ─── Domain setup helpers ────────────────────────────────────────────────────
 function readEnvVar(deployDir, key) {
     try {
@@ -735,6 +899,33 @@ basicauth {
 }
 `;
 }
+function readOpenClawAiConfig(oc) {
+    if (!oc.found || oc.runtime !== "docker")
+        return {};
+    const containerName = oc.containerName ?? "openclaw";
+    const read = (key) => {
+        try {
+            const out = execSync(`docker exec ${containerName} openclaw config get ${key} 2>/dev/null`, { encoding: "utf-8", timeout: 5000 }).trim();
+            if (!out || out === "undefined" || out === "null")
+                return undefined;
+            return out.replace(/^["']|["']$/g, "");
+        }
+        catch {
+            return undefined;
+        }
+    };
+    return {
+        anthropicKey: read("env.ANTHROPIC_API_KEY"),
+        openaiKey: read("env.OPENAI_API_KEY"),
+        geminiKey: read("env.GEMINI_API_KEY"),
+        primaryModel: read("agents.defaults.model.primary"),
+    };
+}
+function maskKey(key) {
+    if (key.length <= 8)
+        return "•".repeat(key.length);
+    return `${key.slice(0, 4)}...${key.slice(-4)}`;
+}
 async function requestDashboardDomainFromCp(cpToken, podId) {
     const cpUrl = process.env.SYNAP_CP_URL ?? "https://api.synap.live";
     const res = await fetch(`${cpUrl}/openclaw/expose-dashboard`, {