spacecode 2.12.0 → 2.12.3

package/dist/repl.mjs

@@ -6904,6 +6904,164 @@ var init_mcp_rpc_pending = __esm({
   }
 });
 
+// ../agent/src/import/mcp-sse-parser.ts
+function createSseParser(onData) {
+  let buffer = "";
+  let dataLines = [];
+  let skipLf = false;
+  function handleLine(line) {
+    if (line === "") {
+      if (dataLines.length === 0) return;
+      const payload = dataLines.join("\n");
+      dataLines = [];
+      onData(payload);
+      return;
+    }
+    if (line.startsWith(":")) return;
+    const colon = line.indexOf(":");
+    if (colon === -1) {
+      if (line === "data") dataLines.push("");
+      return;
+    }
+    if (line.slice(0, colon) !== "data") return;
+    const value = line.slice(colon + 1);
+    dataLines.push(value.startsWith(" ") ? value.slice(1) : value);
+  }
+  return {
+    push(chunk) {
+      buffer += chunk;
+      let start = 0;
+      for (let i = 0; i < buffer.length; i++) {
+        const ch = buffer[i];
+        if (skipLf && i === start && ch === "\n") {
+          skipLf = false;
+          start = i + 1;
+          continue;
+        }
+        skipLf = false;
+        if (ch === "\n") {
+          handleLine(buffer.slice(start, i));
+          start = i + 1;
+        } else if (ch === "\r") {
+          handleLine(buffer.slice(start, i));
+          start = i + 1;
+          if (buffer[i + 1] === "\n") i++, start++;
+          else if (i + 1 === buffer.length) skipLf = true;
+        }
+      }
+      buffer = buffer.slice(start);
+    },
+    end() {
+      buffer = "";
+      dataLines = [];
+      skipLf = false;
+    }
+  };
+}
+var init_mcp_sse_parser = __esm({
+  "../agent/src/import/mcp-sse-parser.ts"() {
+    "use strict";
+  }
+});
+
+// ../agent/src/import/mcp-http-transport.ts
+function createHttpTransport(opts) {
+  const aborter = new AbortController();
+  let sessionId = null;
+  let closed = false;
+  let reported = false;
+  const fail = (reason) => {
+    if (closed || reported) return;
+    reported = true;
+    closed = true;
+    aborter.abort();
+    opts.onClose(reason);
+  };
+  const deliver = (parsed) => {
+    for (const m2 of Array.isArray(parsed) ? parsed : [parsed]) opts.onMessage(m2);
+  };
+  const headers = () => ({
+    ...opts.headers,
+    "content-type": "application/json",
+    accept: "application/json, text/event-stream",
+    "mcp-protocol-version": opts.protocolVersion,
+    ...sessionId !== null ? { "mcp-session-id": sessionId } : {}
+  });
+  async function readStream(res) {
+    if (!res.body) return;
+    const decoder = new TextDecoder();
+    const parser = createSseParser((data) => {
+      let parsed;
+      try {
+        parsed = JSON.parse(data);
+      } catch (err) {
+        if (!(err instanceof SyntaxError)) throw err;
+        return;
+      }
+      deliver(parsed);
+    });
+    for await (const chunk of res.body) parser.push(decoder.decode(chunk, { stream: true }));
+    parser.push(decoder.decode());
+    parser.end();
+  }
+  async function post(message) {
+    const hadSession = sessionId !== null;
+    let res;
+    try {
+      res = await opts.fetch(opts.url, { method: "POST", headers: headers(), body: JSON.stringify(message), signal: aborter.signal });
+    } catch (err) {
+      return fail(`request failed: ${err instanceof Error ? err.name : "error"}`);
+    }
+    if (closed) return;
+    if (res.status === 401 || res.status === 403) return fail("needs authorization (OAuth is not supported)");
+    if (res.status === 404 && hadSession) return fail("session expired");
+    if (res.status >= 400) return fail(`HTTP ${res.status}`);
+    const sid = res.headers.get("mcp-session-id");
+    if (sessionId === null && sid) sessionId = sid;
+    if (res.status === 202) return;
+    const type = (res.headers.get("content-type") ?? "").toLowerCase();
+    try {
+      if (type.startsWith("text/event-stream")) await readStream(res);
+      else if (type.startsWith("application/json")) {
+        let parsed;
+        try {
+          parsed = JSON.parse(await res.text());
+        } catch (err) {
+          if (!(err instanceof SyntaxError)) throw err;
+          return fail("invalid JSON in response");
+        }
+        deliver(parsed);
+      }
+    } catch (err) {
+      fail(`request failed: ${err instanceof Error ? err.name : "error"}`);
+    }
+  }
+  return {
+    send(message) {
+      if (closed) throw new Error(CLOSED);
+      void post(message);
+    },
+    async close() {
+      if (closed) return;
+      closed = true;
+      aborter.abort();
+      if (sessionId === null) return;
+      try {
+        await opts.fetch(opts.url, { method: "DELETE", headers: { ...opts.headers, "mcp-protocol-version": opts.protocolVersion, "mcp-session-id": sessionId } });
+      } catch {
+      }
+    }
+  };
+}
+var CLOSED;
+var init_mcp_http_transport = __esm({
+  "../agent/src/import/mcp-http-transport.ts"() {
+    "use strict";
+    init_mcp_sse_parser();
+    CLOSED = "MCP server connection is closed";
+  }
+});
+
 // ../agent/src/import/mcp-rpc.ts
 function createRpcSession(deps) {
   const pending = new PendingRequests();
@@ -7152,6 +7310,8 @@ var init_src = __esm({
     init_claude_json_mcp();
     init_mcp_rpc_message();
     init_mcp_rpc_pending();
+    init_mcp_sse_parser();
+    init_mcp_http_transport();
     init_mcp_rpc();
     init_mcp_tool_result();
     init_mcp_client();
@@ -7809,7 +7969,7 @@ var init_import_claude = __esm({
     init_api_key();
     init_profile_runtime();
     init_import_adapt();
-    USAGE = "Usage: spacecode import-claude [--dry-run] [--overwrite] [--no-adapt] [--yes] [--restore-original]";
+    USAGE = "Usage: spacecode import claude [--dry-run] [--overwrite] [--no-adapt] [--yes] [--restore-original]";
   }
 });
 
@@ -7924,6 +8084,18 @@ var init_stdio_transport = __esm({
 function approvalEnv(env3) {
   return Object.entries(env3).map(([k2, v2]) => `${k2}=${v2}`).sort();
 }
+function approvalKey(def) {
+  const envNames = approvalEnv(def.env);
+  return def.transport === "http" ? { command: `mcp-http:${def.url}`, args: [], envNames } : { command: def.command, args: def.args, envNames };
+}
+function isSafeMcpUrl(url) {
+  try {
+    const u3 = new URL(url);
+    return u3.protocol === "https:" || u3.protocol === "http:" && ["localhost", "127.0.0.1", "[::1]"].includes(u3.hostname);
+  } catch {
+    return false;
+  }
+}
 function mcpToolName(server, tool) {
   return `mcp__${sanitize2(server)}__${sanitize2(tool)}`;
 }
@@ -7981,11 +8153,10 @@ var init_mcp_manager = __esm({
         }
         for (const def of this.deps.defs) {
           try {
-            if (def.transport !== "stdio") continue;
-            const envNames = approvalEnv(def.env);
-            if (!await this.deps.isStdioApproved({ command: def.command, args: def.args, envNames })) continue;
-            if (!expandServerEnv({ command: def.command, args: def.args, env: def.env }, this.deps.env).ok) continue;
-            const hit = getCachedTools(this.cache, serverCacheKey({ name: def.name, command: def.command, args: def.args, envNames }, tc.hash));
+            const key = approvalKey(def);
+            if (!await this.deps.isStdioApproved(key)) continue;
+            if (!expandServerEnv({ command: def.transport === "http" ? def.url : def.command, args: def.args, env: def.env }, this.deps.env).ok) continue;
+            const hit = getCachedTools(this.cache, serverCacheKey({ name: def.name, ...key }, tc.hash));
             if (hit) this.cachedTools.set(def.name, this.usable(def.name, hit).tools);
           } catch (err) {
             this.cacheNotes.push(`${def.name}: cached tools skipped (${err instanceof Error ? err.message : String(err)})`);
@@ -8038,7 +8209,7 @@ var init_mcp_manager = __esm({
         if (!tc) return Promise.resolve();
         this.cacheWrite = this.cacheWrite.then(async () => {
           try {
-            const key = serverCacheKey({ name: def.name, command: def.command, args: def.args, envNames: approvalEnv(def.env) }, tc.hash);
+            const key = serverCacheKey({ name: def.name, ...approvalKey(def) }, tc.hash);
             const next = putCachedTools(this.cache, key, tools.map((t) => ({ name: t.name, description: t.description, inputSchema: t.inputSchema })));
             if (next === this.cache) return;
             await tc.write(serializeToolCache(next));
@@ -8053,38 +8224,56 @@ var init_mcp_manager = __esm({
         const name = def.name;
         const skip = (reason) => void this.servers.set(name, { name, def, status: "skipped", reason });
         const fail = (reason) => void this.servers.set(name, { name, def, status: "failed", reason });
-        if (def.transport !== "stdio") return skip("http servers are not supported yet");
-        const envNames = approvalEnv(def.env);
+        const http = def.transport === "http";
+        if (http && !isSafeMcpUrl(def.url)) return skip("its URL must be https (or localhost)");
+        const key = approvalKey(def);
         let approved;
         try {
-          approved = await this.deps.isStdioApproved({ command: def.command, args: def.args, envNames });
+          approved = await this.deps.isStdioApproved(key);
         } catch (err) {
           return fail(`approval check failed: ${err instanceof Error ? err.message : String(err)}`);
         }
-        if (!approved) return skip(`its command is not approved on this machine (${def.origin} definition)`);
-        const expanded = expandServerEnv({ command: def.command, args: def.args, env: def.env }, this.deps.env);
+        if (!approved) return skip(`its ${http ? "URL and headers are" : "command is"} not approved on this machine (${def.origin} definition)`);
+        const expanded = expandServerEnv({ command: http ? def.url : def.command, args: def.args, env: def.env }, this.deps.env);
         if (!expanded.ok) return skip(`set ${expanded.missing.join(", ")} in your environment`);
+        if (http && !isSafeMcpUrl(expanded.command)) return skip("its URL must be https (or localhost)");
         this.servers.set(name, { name, def, status: "connecting" });
         let transport;
         try {
           let session2;
           let closeReason = null;
-          transport = (this.deps.start ?? startStdioTransport)({
-            command: expanded.command,
-            args: expanded.args,
-            env: expanded.env,
-            cwd: this.deps.cwd,
-            onMessage: (m2) => void session2.handleMessage(m2),
-            onClose: (reason) => {
-              closeReason = reason;
-              session2.close(reason);
-              const cur = this.servers.get(name);
-              if (cur?.status === "ready") this.servers.set(name, { name, def, status: "failed", reason: `server ${reason}` });
-            }
-          });
-          const t = transport;
+          const onClose = (reason) => {
+            closeReason = reason;
+            session2.close(reason);
+            const cur = this.servers.get(name);
+            if (cur?.status === "ready") this.servers.set(name, { name, def, status: "failed", reason: `server ${reason}` });
+          };
+          let send;
+          if (http) {
+            const t = createHttpTransport({
+              url: expanded.command,
+              headers: expanded.env,
+              fetch: this.deps.fetch ?? ((url, init) => fetch(url, { ...init, redirect: "error" })),
+              protocolVersion: MCP_PROTOCOL_VERSION,
+              onMessage: (m2) => void session2.handleMessage(m2),
+              onClose
+            });
+            transport = t;
+            send = (m2) => t.send(m2);
+          } else {
+            const t = (this.deps.start ?? startStdioTransport)({
+              command: expanded.command,
+              args: expanded.args,
+              env: expanded.env,
+              cwd: this.deps.cwd,
+              onMessage: (m2) => void session2.handleMessage(m2),
+              onClose
+            });
+            transport = t;
+            send = (m2) => t.send(m2);
+          }
           session2 = createRpcSession({
-            send: (m2) => t.send(m2),
+            send,
             setTimer: (fn, ms) => setTimeout(fn, ms),
             clearTimer: (h) => clearTimeout(h)
           });
@@ -8208,10 +8397,10 @@ var init_mcp_manager = __esm({
 async function runApproveMcp(deps) {
   const { defs, statusLines } = await loadMcpDefs(deps);
   if (!deps.quiet) for (const l of statusLines) deps.log(l);
-  const stdio = defs.filter((d) => d.transport === "stdio");
+  const stdio = defs;
   const todo = [];
   for (const d of stdio) {
-    const key = { command: d.command, args: d.args, envNames: approvalEnv(d.env) };
+    const key = approvalKey(d);
     if (await deps.trust.stdioStatus(key) === "unapproved") todo.push(d);
   }
   if (todo.length === 0) {
@@ -8226,13 +8415,18 @@ async function runApproveMcp(deps) {
 ${todo.length} imported MCP server(s) want to run a command on this machine. Nothing spawns until you approve it (you can also run \`spacecode approve-mcp\` later).`);
   let approved = 0;
   for (const d of todo) {
-    deps.log(`
+    deps.log(
+      d.transport === "http" ? `
+MCP server ${show(d.name)} (${d.origin} definition) wants to connect from this machine to:
+  ${show(d.url)}
+  headers it will send (NAME=where the value comes from): ${approvalEnv(d.env).join(", ") || "(none)"}` : `
 MCP server ${show(d.name)} (${d.origin} definition) wants to run on this machine:
   ${show(d.command)} ${d.args.map(show).join(" ")}
-  environment it will receive (NAME=where the value comes from): ${approvalEnv(d.env).join(", ") || "(none)"}`);
-    const answer = (await deps.ask("Approve this command? [y/N] ") ?? "").trim().toLowerCase();
+  environment it will receive (NAME=where the value comes from): ${approvalEnv(d.env).join(", ") || "(none)"}`
+    );
+    const answer = (await deps.ask("Approve? [y/N] ") ?? "").trim().toLowerCase();
     if (answer === "y" || answer === "yes") {
-      await deps.trust.approveStdio({ command: d.command, args: d.args, envNames: approvalEnv(d.env) });
+      await deps.trust.approveStdio(approvalKey(d));
       deps.log("  approved");
       approved++;
     } else deps.log("  not approved");
@@ -35864,7 +36058,7 @@ var require_websocket_server = __commonJS({
     var keyRegex = /^[+/0-9A-Za-z]{22}==$/;
     var RUNNING = 0;
     var CLOSING = 1;
-    var CLOSED = 2;
+    var CLOSED2 = 2;
     var WebSocketServer2 = class extends EventEmitter3 {
       /**
        * Create a `WebSocketServer` instance.
@@ -35993,7 +36187,7 @@ var require_websocket_server = __commonJS({
        * @public
        */
       close(cb) {
-        if (this._state === CLOSED) {
+        if (this._state === CLOSED2) {
           if (cb) {
             this.once("close", () => {
               cb(new Error("The server is not running"));
@@ -36217,7 +36411,7 @@ var require_websocket_server = __commonJS({
       };
     }
     function emitClose(server) {
-      server._state = CLOSED;
+      server._state = CLOSED2;
       server.emit("close");
     }
     function socketOnError() {
@@ -104173,7 +104367,7 @@ Skills are loaded on demand with the skill tool; bodies are not in the prompt. /
       (a) => a.kind === "skill" && (a.name === name || a.name.startsWith(`${name}.`) && a.description.startsWith(SIBLING_PREFIX))
     );
     for (const a of assets) await deps.client.delete("skill", a.name);
-    return `Deleted skill "${name}" and ${assets.length - 1} file(s) from the profile. Re-running import-claude would import it again.`;
+    return `Deleted skill "${name}" and ${assets.length - 1} file(s) from the profile. Re-running "spacecode import claude" would import it again.`;
   }
   return "Usage: /skills | /skills show <name> [file] | /skills delete <name>";
 }
@@ -104418,9 +104612,24 @@ async function runCoreTurn(d, prompt) {
       ...body === void 0 ? {} : { body: JSON.stringify(body) },
       signal: d.signal
     });
-    if (!res.ok) throw new CoreTurnError(`core run request failed (${res.status}) ${method} ${path13.split("?")[0]}`);
+    if (!res.ok) throw new CoreTurnError(`core run request failed (${res.status}) ${method} ${path13.split("?")[0]}`, res.status);
     return res.json();
   };
+  const poll = async (path13) => {
+    for (let attempt = 0; ; attempt++) {
+      try {
+        return await call("GET", path13);
+      } catch (err) {
+        const transient = err instanceof CoreTurnError && err.status !== void 0 && err.status >= 500;
+        if (!transient || d.signal.aborted) throw err;
+        if (attempt >= POLL_RETRIES) throw new CoreTurnError(`${err.message} (gave up after ${POLL_RETRIES} retries)`, err.status);
+        d.emit({ type: "text", seq: ++seq, content: `(run service answered ${err.status}; retry ${attempt + 1}/${POLL_RETRIES})
+
+` });
+        await d.sleep(Math.min(8e3, 1e3 * 2 ** attempt));
+      }
+    }
+  };
   let runId = d.getRunId();
   if (!runId) {
     const created = await call("POST", "", {
@@ -104442,7 +104651,7 @@ async function runCoreTurn(d, prompt) {
   let state = null;
   for (; ; ) {
     if (d.signal.aborted) throw new CoreTurnError("aborted");
-    const events = (await call("GET", `/${runId}/events?after=${cur.after}&limit=200`)).events;
+    const events = (await poll(`/${runId}/events?after=${cur.after}&limit=200`)).events;
     for (const e of events) {
       cur.after = Math.max(cur.after, e.seq);
       if (!e.applied) continue;
@@ -104454,7 +104663,7 @@ async function runCoreTurn(d, prompt) {
       }
       if (e.type === "verifier_result" && Array.isArray(p.problems) && p.problems.length > 0) say(`task ${String(p.taskId)}: verifier: ${p.problems.join("; ")}`);
     }
-    state = (await call("GET", `/${runId}`)).state;
+    state = (await poll(`/${runId}`)).state;
     const now = {};
     for (const id of state.order) now[id] = state.tasks[id].status;
     const changed = state.order.filter((id) => now[id] !== cur.known[id]);
@@ -104485,7 +104694,7 @@ async function runCoreTurn(d, prompt) {
   cur.tokensBase = state.tokensUsed;
   return { success: (state.status === "done" || state.status === "needs_user") && patchFailures === 0, text: lastText, tokens };
 }
-var newRunCursor, TERMINAL, DEFAULT_BUDGET, DEFAULT_MAX_WAIT_MS, CoreTurnError;
+var newRunCursor, TERMINAL, DEFAULT_BUDGET, DEFAULT_MAX_WAIT_MS, CoreTurnError, POLL_RETRIES;
 var init_core_turn = __esm({
   "src/core/core-turn.ts"() {
     "use strict";
@@ -104494,7 +104703,12 @@ var init_core_turn = __esm({
     DEFAULT_BUDGET = 5e5;
     DEFAULT_MAX_WAIT_MS = 30 * 6e4;
     CoreTurnError = class extends Error {
+      constructor(message, status) {
+        super(message);
+        this.status = status;
+      }
     };
+    POLL_RETRIES = 5;
   }
 });
 
@@ -105873,7 +106087,13 @@ function clearOnResize(stdout) {
 
 // src/index.tsx
 var import_jsx_runtime14 = __toESM(require_jsx_runtime(), 1);
-if (process.argv[2] === "import-claude") {
+if (process.argv[2] === "import" || process.argv[2] === "import-claude") {
+  const importArgs = process.argv[2] === "import" ? process.argv.slice(4) : process.argv.slice(3);
+  const importAgent = process.argv[2] === "import" ? process.argv[3] : "claude";
+  if (importAgent !== "claude") {
+    console.error(`Unknown agent "${importAgent ?? ""}". Supported: claude`);
+    process.exit(2);
+  }
   const { runImportClaude: runImportClaude2 } = await Promise.resolve().then(() => (init_import_claude(), import_claude_exports));
   const { readFile: readFile12, readdir: readdir6 } = await import("node:fs/promises");
   const { execFile: execFile6 } = await import("node:child_process");
@@ -105881,7 +106101,7 @@ if (process.argv[2] === "import-claude") {
     execFile6("git", ["rev-parse", "--show-toplevel"], { cwd: process.cwd() }, (err, stdout) => resolve2(err ? null : stdout.trim() || null));
   });
   const code = await runImportClaude2({
-    argv: process.argv.slice(2),
+    argv: ["import-claude", ...importArgs],
     env: process.env,
     fs: { readFile: (p) => readFile12(p, "utf-8"), readdir: (p) => readdir6(p) },
     readFile: (p) => readFile12(p, "utf-8"),

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "spacecode",
-  "version": "2.12.0",
+  "version": "2.12.3",
   "description": "SpaceCode - launch cloud dev environments with AI coding agents",
   "license": "MIT",
   "type": "commonjs",