summer-engine 2.6.6 → 2.8.0

package/dist/commands/config.js

@@ -0,0 +1,53 @@
+import { Command } from "commander";
+import { CONFIG_KEYS, getConfigValue, isConfigKey, readSummerConfig, setConfigValue, unsetConfigValue, } from "../lib/config.js";
+function requireKey(value) {
+    if (isConfigKey(value))
+        return value;
+    throw new Error(`Unknown config key "${value}". Recovery: use one of ${CONFIG_KEYS.join(", ")}.`);
+}
+async function printConfig(json) {
+    const config = await readSummerConfig();
+    const values = Object.fromEntries(CONFIG_KEYS.map((key) => [key, getConfigValue(config, key) ?? null]));
+    if (json) {
+        console.log(JSON.stringify(values, null, 2));
+        return;
+    }
+    for (const [key, value] of Object.entries(values)) {
+        console.log(`${key}=${value ?? "(not set)"}`);
+    }
+}
+export const configCommand = new Command("config")
+    .description("Read or update the shared ~/.summer configuration")
+    .option("--json", "Print all configuration as JSON")
+    .action(async (opts) => printConfig(Boolean(opts.json)));
+configCommand
+    .command("get")
+    .description("Read one configuration value")
+    .argument("<key>", `One of: ${CONFIG_KEYS.join(", ")}`)
+    .action(async (rawKey) => {
+    const key = requireKey(rawKey);
+    const value = getConfigValue(await readSummerConfig(), key);
+    if (value === undefined) {
+        throw new Error(`${key} is not set. Recovery: run "summer config set ${key} <value>", or rely on the documented default.`);
+    }
+    console.log(value);
+});
+configCommand
+    .command("set")
+    .description("Set one non-secret configuration value")
+    .argument("<key>", `One of: ${CONFIG_KEYS.join(", ")}`)
+    .argument("<value>")
+    .action(async (rawKey, value) => {
+    const key = requireKey(rawKey);
+    await setConfigValue(key, value);
+    console.log(`Set ${key}.`);
+});
+configCommand
+    .command("unset")
+    .description("Remove one configuration override")
+    .argument("<key>", `One of: ${CONFIG_KEYS.join(", ")}`)
+    .action(async (rawKey) => {
+    const key = requireKey(rawKey);
+    await unsetConfigValue(key);
+    console.log(`Unset ${key}.`);
+});

package/dist/commands/create.d.ts

@@ -1,2 +1,3 @@
 import { Command } from "commander";
 export declare const createCommand: Command;
+export declare function renderProjectSettings(name: string, mainScene: string): string;

package/dist/commands/create.js

@@ -1,14 +1,16 @@
 import { Command } from "commander";
-import { existsSync, mkdirSync, writeFileSync } from "fs";
-import { join, resolve } from "path";
+import { copyFileSync, existsSync, mkdirSync, readdirSync, writeFileSync } from "fs";
+import { dirname, join, resolve } from "path";
+import { fileURLToPath } from "url";
 import { fetchRemoteTemplates, cloneTemplate, matchTemplate } from "../lib/remote-templates.js";
+import { SUMMER_ENGINE_COMPATIBILITY } from "../lib/summer-compatibility.js";
 const BUILTIN_TEMPLATES = [
     {
         name: "empty",
         description: "Empty 3D project with just a root node",
         builtin: true,
         generate: (dir, name) => {
-            writeFileSync(join(dir, "project.godot"), projectGodot(name, "res://main.tscn"));
+            writeFileSync(join(dir, "project.godot"), renderProjectSettings(name, "res://main.tscn"));
             writeFileSync(join(dir, "main.tscn"), emptyScene());
         },
     },
@@ -17,11 +19,34 @@ const BUILTIN_TEMPLATES = [
         description: "3D scene with camera, light, and floor",
         builtin: true,
         generate: (dir, name) => {
-            writeFileSync(join(dir, "project.godot"), projectGodot(name, "res://main.tscn"));
+            writeFileSync(join(dir, "project.godot"), renderProjectSettings(name, "res://main.tscn"));
             writeFileSync(join(dir, "main.tscn"), basicScene3D());
         },
     },
 ];
+/**
+ * Copy the autopilot verification scaffold into a fresh project.
+ *
+ * Every project gets a working example of how to prove its own gameplay: a probe
+ * that drives the player with real input, saves rendered frames, asserts, and
+ * exits. Without it every agent reinvents verification from scratch, and most
+ * settle for asking the user to play the game instead.
+ *
+ * Never overwrites — an existing tests/autopilot/ is the user's, not ours.
+ */
+function scaffoldAutopilot(projectDir) {
+    const here = dirname(fileURLToPath(import.meta.url));
+    // dist/commands/create.js -> package root
+    const source = resolve(here, "..", "..", "assets", "autopilot");
+    const target = join(projectDir, "tests", "autopilot");
+    if (!existsSync(source) || existsSync(target))
+        return false;
+    mkdirSync(target, { recursive: true });
+    for (const entry of readdirSync(source)) {
+        copyFileSync(join(source, entry), join(target, entry));
+    }
+    return true;
+}
 export const createCommand = new Command("create")
     .description("Create a new Summer Engine project. Built-in templates work offline; community templates clone from github.com/SummerEngine/template-*.")
     .argument("<template>", `Template slug. Built-in: ${BUILTIN_TEMPLATES.map((t) => t.name).join(", ")}. Or any community slug — see "summer list templates".`)
@@ -39,9 +64,12 @@ export const createCommand = new Command("create")
         console.log(`Creating project from built-in '${templateName}' template...`);
         mkdirSync(fullPath, { recursive: true });
         builtin.generate(fullPath, dirName);
+        const scaffolded = scaffoldAutopilot(fullPath);
         console.log(`\nProject created at ${fullPath}`);
         console.log("\nNext steps:");
         console.log(`  summer run ${dirName}`);
+        if (scaffolded)
+            console.log(`  bash ${dirName}/tests/autopilot/run.sh   (verify the game without opening it)`);
         console.log("  Ask your agent to run summer:brainstorm-game to create .summer/GameSoul.md");
         return;
     }
@@ -83,21 +111,25 @@ export const createCommand = new Command("create")
         console.error(err.message);
         process.exit(1);
     }
+    const scaffolded = scaffoldAutopilot(fullPath);
     console.log(`\nProject created at ${fullPath}`);
     console.log("Source: " + remote.url);
     console.log("\nNext steps:");
     console.log(`  summer run ${dirName}`);
+    if (scaffolded)
+        console.log(`  bash ${dirName}/tests/autopilot/run.sh   (verify the game without opening it)`);
     console.log("  Ask your agent to run summer:brainstorm-game to create .summer/GameSoul.md");
 });
-function projectGodot(name, mainScene) {
+export function renderProjectSettings(name, mainScene) {
     return `; Summer Engine Project
 ; Generated by summer-engine CLI
+; Technical base ${SUMMER_ENGINE_COMPATIBILITY.currentTechnicalBaseVersion}; Summer follows upstream continuously
 
 [application]
 
 config/name="${name}"
 run/main_scene="${mainScene}"
-config/features=PackedStringArray("4.5")
+config/features=PackedStringArray("${SUMMER_ENGINE_COMPATIBILITY.projectFeatureTag}")
 
 [rendering]
 

package/dist/commands/debug.d.ts

@@ -0,0 +1,2 @@
+import { Command } from "commander";
+export declare const debugCommand: Command;

package/dist/commands/debug.js

@@ -0,0 +1,44 @@
+import { Command } from "commander";
+import { createDebugReportArtifact, redactDebugReport } from "../lib/debug-report.js";
+import { c, sym, tildeify } from "../lib/format.js";
+function parsePositiveInt(value, fallback) {
+    if (!value)
+        return fallback;
+    const parsed = Number.parseInt(value, 10);
+    return Number.isFinite(parsed) && parsed > 0 ? parsed : fallback;
+}
+export const debugCommand = new Command("debug")
+    .description("Create a support-ready Markdown debug report")
+    .argument("[issue...]", "What is broken or surprising?")
+    .option("-o, --output <path>", "Write the report to this path")
+    .option("--json", "Print JSON with the report path and collected data")
+    .option("--play", "Also launch the game briefly and collect post-play diagnostics")
+    .option("--no-doctor", "Skip summer doctor checks")
+    .option("--max-console-lines <n>", "Console lines to collect", "200")
+    .option("--max-debugger-entries <n>", "Debugger entries to collect", "100")
+    .option("--play-wait-ms <n>", "Milliseconds to wait after --play starts", "2500")
+    .action(async (issueParts, opts) => {
+    const issue = issueParts.join(" ").trim();
+    const artifact = await createDebugReportArtifact({
+        issue,
+        outputPath: opts.output,
+        includePlaySession: Boolean(opts.play),
+        includeDoctor: opts.doctor !== false,
+        maxConsoleLines: parsePositiveInt(opts.maxConsoleLines, 200),
+        maxDebuggerEntries: parsePositiveInt(opts.maxDebuggerEntries, 100),
+        playWaitMs: parsePositiveInt(opts.playWaitMs, 2500),
+    });
+    if (opts.json) {
+        console.log(JSON.stringify({
+            ok: true,
+            path: artifact.path,
+            report: redactDebugReport(artifact.report),
+        }, null, 2));
+        return;
+    }
+    console.log("");
+    console.log(`${sym.ok()} ${c.bold("Summer debug report created")}`);
+    console.log(`   ${tildeify(artifact.path)}`);
+    console.log("");
+    console.log("Review it before sending. It omits auth tokens, but may include local paths and stack traces.");
+});

package/dist/commands/doctor.js

@@ -3,14 +3,23 @@ import { existsSync } from "fs";
 import { createRequire } from "node:module";
 import { platform } from "os";
 import { Command } from "commander";
+import { Client } from "@modelcontextprotocol/sdk/client/index.js";
+import { StdioClientTransport } from "@modelcontextprotocol/sdk/client/stdio.js";
 import { getAuthToken, getUserInfo } from "../lib/auth.js";
 import { isGitAvailable } from "../lib/cloud/checkpoint.js";
 import { checkEngineHealth, getApiPort, getApiToken } from "../lib/engine.js";
 import { brandLine, c, pad, sym, tildeify } from "../lib/format.js";
+import { getMcpLogPath } from "../lib/mcp-log.js";
 import { getProjectMemorySummary } from "../lib/project-memory.js";
 import { buildCliVersionCheck, buildSkillsVersionCheck, defaultSkillMarkerCandidates, fetchLatestRegistryVersion, } from "../lib/version-check.js";
 const require = createRequire(import.meta.url);
 const { version } = require("../../package.json");
+const MIN_EXPECTED_MCP_TOOLS = 50;
+const REQUIRED_MCP_TOOLS = [
+    "summer_get_project_context",
+    "summer_generate_image",
+    "summer_create_debug_report",
+];
 const MAC_ENGINE_PATHS = [
     "/Applications/Summer.app/Contents/MacOS/Summer",
     `${process.env.HOME}/Applications/Summer.app/Contents/MacOS/Summer`,
@@ -21,7 +30,7 @@ const WIN_ENGINE_PATHS = [
     `${process.env.PROGRAMFILES}\\Summer Engine\\Summer.exe`,
 ];
 export const doctorCommand = new Command("doctor")
-    .description("Diagnose Node, login, engine, project memory, local API, and MCP boot")
+    .description("Diagnose Node, login, engine, project memory, local API, and MCP registration")
     .option("--json", "Print diagnostics as JSON")
     .action(async (opts) => {
     if (!opts.json) {
@@ -53,6 +62,7 @@ export async function runDoctor(options = {}) {
     checks.push(await checkLocalApi());
     checks.push(await checkProjectMemory());
     checks.push(await checkMcpBoot());
+    checks.push(await checkMcpToolsList());
     const result = summarizeChecks(checks);
     if (!options.quiet) {
         if (options.json) {
@@ -237,8 +247,8 @@ async function checkProjectMemory() {
     };
 }
 async function checkMcpBoot() {
-    const cliPath = process.argv[1];
-    if (!cliPath) {
+    const resolved = resolveCurrentMcpCommand();
+    if (!resolved) {
         return {
             id: "mcp-boot",
             label: "MCP Server",
@@ -247,9 +257,7 @@ async function checkMcpBoot() {
         };
     }
     return new Promise((resolve) => {
-        const command = cliPath.endsWith(".js") ? process.execPath : cliPath;
-        const args = cliPath.endsWith(".js") ? [cliPath, "mcp"] : ["mcp"];
-        const child = spawn(command, args, {
+        const child = spawn(resolved.command, resolved.args, {
             env: process.env,
             stdio: ["pipe", "pipe", "pipe"],
         });
@@ -269,7 +277,7 @@ async function checkMcpBoot() {
                 label: "MCP Server",
                 status: "fail",
                 message: "MCP server did not finish startup within 3 seconds.",
-                details: trimOutput({ stdout, stderr }),
+                details: { ...trimOutput({ stdout, stderr }), ...resolved },
             });
         }, 3000);
         child.stderr.on("data", (chunk) => {
@@ -281,6 +289,7 @@ async function checkMcpBoot() {
                     label: "MCP Server",
                     status: "ok",
                     message: "ready",
+                    details: { ...resolved },
                 });
             }
         });
@@ -294,6 +303,7 @@ async function checkMcpBoot() {
                 label: "MCP Server",
                 status: "fail",
                 message: `Could not start MCP server: ${error.message}`,
+                details: { ...resolved },
             });
         });
         child.on("exit", (code) => {
@@ -304,12 +314,106 @@ async function checkMcpBoot() {
                     label: "MCP Server",
                     status: "fail",
                     message: `MCP server exited before reporting readiness${code === null ? "" : ` (code ${code})`}.`,
-                    details: trimOutput({ stdout, stderr }),
+                    details: { ...trimOutput({ stdout, stderr }), ...resolved },
                 });
             }
         });
     });
 }
+function resolveCurrentMcpCommand() {
+    const cliPath = process.argv[1];
+    if (!cliPath)
+        return null;
+    return cliPath.endsWith(".js")
+        ? { command: process.execPath, args: [cliPath, "mcp"] }
+        : { command: cliPath, args: ["mcp"] };
+}
+function inheritedEnv(extra = {}) {
+    const env = {};
+    for (const [key, value] of Object.entries(process.env)) {
+        if (value !== undefined)
+            env[key] = value;
+    }
+    return { ...env, ...extra };
+}
+async function checkMcpToolsList() {
+    const resolved = resolveCurrentMcpCommand();
+    if (!resolved) {
+        return {
+            id: "mcp-tools-list",
+            label: "MCP Tools",
+            status: "fail",
+            message: "Could not resolve the current Summer CLI entrypoint.",
+        };
+    }
+    const client = new Client({ name: "summer-doctor", version });
+    const transport = new StdioClientTransport({
+        ...resolved,
+        env: inheritedEnv({ SUMMER_MCP_DOCTOR: "1" }),
+        stderr: "pipe",
+    });
+    let stderr = "";
+    transport.stderr?.on("data", (chunk) => {
+        stderr += Buffer.isBuffer(chunk) ? chunk.toString("utf-8") : String(chunk);
+    });
+    try {
+        await client.connect(transport, { timeout: 5000 });
+        const listed = await client.listTools(undefined, { timeout: 5000 });
+        const toolNames = listed.tools.map((tool) => tool.name).sort();
+        const missing = REQUIRED_MCP_TOOLS.filter((tool) => !toolNames.includes(tool));
+        const details = {
+            ...resolved,
+            toolCount: toolNames.length,
+            requiredTools: REQUIRED_MCP_TOOLS,
+            missing,
+            server: client.getServerVersion(),
+            stderr: stderr.trim().slice(-1000),
+            logPath: getMcpLogPath(),
+        };
+        if (missing.length > 0) {
+            return {
+                id: "mcp-tools-list",
+                label: "MCP Tools",
+                status: "fail",
+                message: `missing required tools: ${missing.join(", ")}`,
+                details,
+            };
+        }
+        if (toolNames.length < MIN_EXPECTED_MCP_TOOLS) {
+            return {
+                id: "mcp-tools-list",
+                label: "MCP Tools",
+                status: "fail",
+                message: `only ${toolNames.length} tools listed; expected ${MIN_EXPECTED_MCP_TOOLS}+`,
+                details,
+            };
+        }
+        return {
+            id: "mcp-tools-list",
+            label: "MCP Tools",
+            status: "ok",
+            message: `${toolNames.length} tools registered`,
+            details,
+        };
+    }
+    catch (error) {
+        return {
+            id: "mcp-tools-list",
+            label: "MCP Tools",
+            status: "fail",
+            message: `protocol handshake/list failed: ${error instanceof Error ? error.message : String(error)}`,
+            details: {
+                ...resolved,
+                stderr: stderr.trim().slice(-1000),
+                logPath: getMcpLogPath(),
+            },
+        };
+    }
+    finally {
+        await client.close().catch(() => undefined);
+        await transport.close().catch(() => undefined);
+    }
+}
 function summarizeChecks(checks) {
     const summary = {
         ok: checks.filter((check) => check.status === "ok").length,

package/dist/commands/list.js

@@ -55,7 +55,7 @@ function listProjects() {
         }
     }
     if (projects.length === 0) {
-        console.log("No Summer Engine / Godot projects found in current directory.");
+        console.log("No Summer Engine projects found in current directory.");
         console.log("\nCreate one: summer create 3d-basic my-game");
         return;
     }

package/dist/commands/login.d.ts

@@ -1,2 +1,21 @@
 import { Command } from "commander";
 export declare const loginCommand: Command;
+export interface CreatorLoginDependencies {
+    openUrl: (url: string) => Promise<unknown>;
+    readSecret: (prompt: string) => Promise<string>;
+    log: (message: string) => void;
+}
+/**
+ * The browser session mints the token; the token is pasted once into a hidden
+ * prompt. This deliberately does not replace the core Summer login JWT.
+ */
+export declare function runCreatorLogin(overrides?: Partial<CreatorLoginDependencies>): Promise<void>;
+export interface LoginDependencies {
+    fetch: typeof fetch;
+    openUrl: (url: string) => Promise<unknown>;
+    randomId: () => string;
+    sleep: (ms: number) => Promise<void>;
+    now: () => number;
+    log: (message: string) => void;
+}
+export declare function runLogin(overrides?: Partial<LoginDependencies>): Promise<void>;

package/dist/commands/login.js

@@ -1,49 +1,143 @@
 import { Command } from "commander";
 import { randomUUID } from "crypto";
 import open from "open";
-import { getAuthToken, saveAuthToken, saveCloudToken, saveUserInfo } from "../lib/auth.js";
-const GATEWAY_URL = process.env.SUMMER_GATEWAY_URL || "https://www.summerengine.com";
+import { getAuthToken, getCreatorToken, saveCreatorToken, saveLoginSession, } from "../lib/auth.js";
+import { getCreatorApiUrl, getGatewayUrl } from "../lib/config.js";
 const POLL_INTERVAL_MS = 2000;
 const POLL_TIMEOUT_MS = 120000;
 export const loginCommand = new Command("login")
     .description("Sign in to Summer Engine via your browser")
+    .option("--creator", "Connect a separately scoped Summercraft creator token for publishing")
     .option("--force", "Force re-authentication even if already logged in")
     .action(async (opts) => {
+    if (opts.creator) {
+        const existingCreator = await getCreatorToken();
+        if (existingCreator && !opts.force) {
+            console.log("A creator token is already connected. Use --creator --force to replace it.");
+            return;
+        }
+        await runCreatorLogin();
+        return;
+    }
     const existing = await getAuthToken();
     if (existing && !opts.force) {
         console.log("Already logged in. Use --force to re-authenticate.");
         return;
     }
-    await doLogin();
+    await runLogin();
 });
-async function doLogin() {
-    const sessionId = randomUUID();
-    const loginUrl = `${GATEWAY_URL}/login?cli_session=${sessionId}`;
-    console.log("Sign in at: " + loginUrl);
-    console.log("");
+async function readHiddenLine(prompt) {
+    if (!process.stdin.isTTY || !process.stdout.isTTY) {
+        process.stdout.write(prompt);
+        let value = "";
+        for await (const chunk of process.stdin)
+            value += String(chunk);
+        return value.trim();
+    }
+    process.stdout.write(prompt);
+    const input = process.stdin;
+    const wasRaw = input.isRaw;
+    input.setRawMode(true);
+    input.resume();
+    return new Promise((resolve, reject) => {
+        let value = "";
+        const finish = (error) => {
+            input.off("data", onData);
+            input.setRawMode(Boolean(wasRaw));
+            input.pause();
+            process.stdout.write("\n");
+            if (error)
+                reject(error);
+            else
+                resolve(value.trim());
+        };
+        const onData = (chunk) => {
+            for (const char of String(chunk)) {
+                if (char === "\u0003") {
+                    finish(new Error("Creator token entry cancelled."));
+                    return;
+                }
+                if (char === "\r" || char === "\n" || char === "\u0004") {
+                    finish();
+                    return;
+                }
+                if (char === "\u007f" || char === "\b") {
+                    value = value.slice(0, -1);
+                }
+                else if (char >= " ") {
+                    value += char;
+                }
+            }
+        };
+        input.on("data", onData);
+    });
+}
+const defaultCreatorLoginDependencies = {
+    openUrl: open,
+    readSecret: readHiddenLine,
+    log: console.log,
+};
+/**
+ * The browser session mints the token; the token is pasted once into a hidden
+ * prompt. This deliberately does not replace the core Summer login JWT.
+ */
+export async function runCreatorLogin(overrides = {}) {
+    const deps = { ...defaultCreatorLoginDependencies, ...overrides };
+    const settingsUrl = `${await getCreatorApiUrl()}/creator/settings/tokens`;
+    deps.log(`Opening creator token settings: ${settingsUrl}`);
+    deps.log('Mint a token with the exact "publish" scope, copy its one-time sc_ value, then return here.');
     try {
-        await open(loginUrl);
+        await deps.openUrl(settingsUrl);
     }
     catch {
-        console.log("Could not open browser. Copy the URL above and open it manually.");
-        console.log("");
+        deps.log("Could not open the browser. Copy the URL above and open it manually.");
     }
-    console.log("Waiting for authentication...");
-    const pollUrl = `${GATEWAY_URL}/api/auth/cli-login?session=${sessionId}`;
-    const startTime = Date.now();
+    const token = await deps.readSecret("Creator token (input hidden): ");
+    await saveCreatorToken(token);
+    deps.log("Creator publishing connected. Your core Summer login token was not changed.");
+}
+const defaultDependencies = {
+    fetch,
+    openUrl: open,
+    randomId: randomUUID,
+    sleep: (ms) => new Promise((resolve) => setTimeout(resolve, ms)),
+    now: Date.now,
+    log: console.log,
+};
+export async function runLogin(overrides = {}) {
+    const deps = { ...defaultDependencies, ...overrides };
+    const gatewayUrl = await getGatewayUrl();
+    const sessionId = deps.randomId();
+    const loginUrl = `${gatewayUrl}/login?cli_session=${encodeURIComponent(sessionId)}`;
+    deps.log("Sign in at: " + loginUrl);
+    deps.log("");
+    try {
+        await deps.openUrl(loginUrl);
+    }
+    catch {
+        deps.log("Could not open browser. Copy the URL above and open it manually.");
+        deps.log("");
+    }
+    deps.log("Waiting for authentication...");
+    const pollUrl = `${gatewayUrl}/api/auth/cli-login?session=${encodeURIComponent(sessionId)}`;
+    const startTime = deps.now();
     let lastError = null;
-    while (Date.now() - startTime < POLL_TIMEOUT_MS) {
-        await sleep(POLL_INTERVAL_MS);
+    while (deps.now() - startTime < POLL_TIMEOUT_MS) {
+        await deps.sleep(POLL_INTERVAL_MS);
         try {
-            const res = await fetch(pollUrl, {
+            const res = await deps.fetch(pollUrl, {
                 signal: AbortSignal.timeout(5000),
             });
             if (!res.ok) {
                 if (res.status === 503) {
-                    lastError = "Server not ready (Redis/auth not configured). Try again later.";
+                    lastError =
+                        "The login service is unavailable (Redis/auth is not configured).";
+                }
+                else if (res.status >= 400 && res.status < 500) {
+                    lastError = `The login request was rejected (${res.status}).`;
                 }
                 else if (res.status >= 500) {
-                    lastError = `Server error (${res.status}). Try again later.`;
+                    lastError = `The login service failed (${res.status}).`;
                 }
                 continue;
             }
@@ -51,28 +145,21 @@ async function doLogin() {
             if (data.status === "pending")
                 continue;
             if (data.status === "complete" && data.token) {
-                await saveAuthToken(data.token);
-                if (data.cloudToken) {
-                    await saveCloudToken(data.cloudToken);
-                }
-                if (data.user) {
-                    await saveUserInfo(data.user);
-                }
-                console.log(`\nLogged in as ${data.user?.email || "unknown"}`);
+                await saveLoginSession({
+                    token: data.token,
+                    cloudToken: data.cloudToken,
+                    user: data.user,
+                    scopes: data.scopes,
+                    cloudScopes: data.cloudScopes,
+                });
+                deps.log(`\nLogged in as ${data.user?.email || "unknown"}`);
                 return;
             }
+            lastError = "The login service returned an incomplete authentication result.";
         }
         catch (err) {
             lastError = err instanceof Error ? err.message : "Network error";
         }
     }
-    console.error("\nLogin timed out. Please try again.");
-    if (lastError) {
-        console.error(`Last error: ${lastError}`);
-    }
-    console.error("\nDid you click \"Yes, Sign In\" in the browser after opening the URL?");
-    process.exit(1);
-}
-function sleep(ms) {
-    return new Promise((resolve) => setTimeout(resolve, ms));
+    throw new Error(`Login timed out after 120 seconds.${lastError ? ` Last error: ${lastError}` : ""} Recovery: run "summer login" again, complete "Yes, Sign In" in the browser, and return to the terminal within two minutes.`);
 }

package/dist/commands/logout.js

@@ -1,23 +1,10 @@
 import { Command } from "commander";
-import { unlink } from "fs/promises";
-import { join } from "path";
-import { getSummerDir } from "../lib/auth.js";
+import { clearAuthCredentials } from "../lib/auth.js";
 export const logoutCommand = new Command("logout")
     .description("Sign out and clear stored auth tokens")
     .action(async () => {
-    const dir = getSummerDir();
-    const files = ["auth-token", "cloud-token", "user.json"];
-    let cleared = false;
-    for (const file of files) {
-        try {
-            await unlink(join(dir, file));
-            cleared = true;
-        }
-        catch {
-            // File doesn't exist, that's fine
-        }
-    }
-    if (cleared) {
+    const removed = await clearAuthCredentials();
+    if (removed > 0) {
         console.log("Logged out. Auth tokens cleared.");
     }
     else {

package/dist/commands/logs.d.ts

@@ -0,0 +1,2 @@
+import { Command } from "commander";
+export declare const logsCommand: Command;