sparkecoder 0.1.107 → 0.1.109

package/dist/cli.js

@@ -854,6 +854,14 @@ var init_types = __esm({
         // If not set, defaults to http://{host}:{port}
         publicUrl: z.string().url().optional()
       }).default({ port: 3141, host: "127.0.0.1" }),
+      // Per-tunnel unguessable webhook URL prefix. Set by
+      // `cloudflared-setup --remote` from the response of POST
+      // /tunnels/ensure. When present, the local server mounts public
+      // inbound webhooks (Slack events, inbox) under /w/<token>/...
+      // instead of /api/*. When absent, falls back to /api/*.
+      webhooks: z.object({
+        token: z.string().optional()
+      }).optional(),
       // Database path (used for local SQLite - ignored if remoteServer is configured)
       databasePath: z.string().optional().default("./sparkecoder.db"),
       // Remote server configuration (for centralized storage)
@@ -961,7 +969,9 @@ __export(config_exports, {
   saveAuthKey: () => saveAuthKey,
   setApiKey: () => setApiKey,
   setMcpServers: () => setMcpServers,
-  setSlackConfig: () => setSlackConfig
+  setPublicUrl: () => setPublicUrl,
+  setSlackConfig: () => setSlackConfig,
+  setWebhookToken: () => setWebhookToken
 });
 import { existsSync, readFileSync, mkdirSync, writeFileSync } from "fs";
 import { resolve, dirname, join } from "path";
@@ -1223,6 +1233,55 @@ function setMcpServers(servers2) {
     console.warn("[config] failed to persist mcp config:", err?.message || err);
   }
 }
+function setWebhookToken(token) {
+  if (cachedConfig) {
+    cachedConfig.webhooks = {
+      ...cachedConfig.webhooks ?? {},
+      token
+    };
+  }
+  try {
+    const cwdPath = resolve(process.cwd(), "sparkecoder.config.json");
+    const target = existsSync(cwdPath) ? cwdPath : join(ensureAppDataDirectory(), "sparkecoder.config.json");
+    let raw = {};
+    if (existsSync(target)) {
+      try {
+        raw = JSON.parse(readFileSync(target, "utf-8"));
+      } catch {
+        raw = {};
+      }
+    } else {
+      raw = createDefaultConfig();
+    }
+    raw.webhooks = { ...raw.webhooks || {}, token };
+    writeFileSync(target, JSON.stringify(raw, null, 2));
+  } catch (err) {
+    console.warn("[config] failed to persist webhook token:", err?.message || err);
+  }
+}
+function setPublicUrl(publicUrl) {
+  if (cachedConfig) {
+    cachedConfig.server = { ...cachedConfig.server ?? {}, publicUrl };
+  }
+  try {
+    const cwdPath = resolve(process.cwd(), "sparkecoder.config.json");
+    const target = existsSync(cwdPath) ? cwdPath : join(ensureAppDataDirectory(), "sparkecoder.config.json");
+    let raw = {};
+    if (existsSync(target)) {
+      try {
+        raw = JSON.parse(readFileSync(target, "utf-8"));
+      } catch {
+        raw = {};
+      }
+    } else {
+      raw = createDefaultConfig();
+    }
+    raw.server = { ...raw.server || {}, publicUrl };
+    writeFileSync(target, JSON.stringify(raw, null, 2));
+  } catch (err) {
+    console.warn("[config] failed to persist publicUrl:", err?.message || err);
+  }
+}
 function clearSlackConfig() {
   if (cachedConfig) cachedConfig.slack = {};
   try {
@@ -9557,7 +9616,9 @@ function buildScheduleTool(opts) {
 }
 function buildWebhookUrl(opts, token) {
   const base = opts.publicBaseUrl?.replace(/\/$/, "") || opts.baseUrl.replace(/\/$/, "");
-  return `${base}/api/inbox/${token}`;
+  const cfg = getConfig();
+  const webhookPrefix2 = cfg?.webhooks?.token ? `/w/${cfg.webhooks.token}` : "/api";
+  return `${base}${webhookPrefix2}/inbox/${token}`;
 }
 function buildWebhookTool(opts) {
   return tool14({
@@ -9607,6 +9668,7 @@ var init_orchestrator_actions = __esm({
     "use strict";
     init_messenger();
     init_schedules_store();
+    init_config();
     init_webhooks_store();
     AGENT_STATUS_ENUM = z15.enum(["running", "needs_attention", "completed", "failed", "idle"]);
     agentInputSchema = z15.object({
@@ -14656,8 +14718,8 @@ async function findOrCreateOrchestratorId() {
     const all = await sessionQueries.list(500, 0);
     const existing = all.find((s) => s.config?.role === "orchestrator");
     if (existing) return existing.id;
-    const { getConfig: getConfig3 } = await Promise.resolve().then(() => (init_config(), config_exports));
-    const cfg = getConfig3();
+    const { getConfig: getConfig2 } = await Promise.resolve().then(() => (init_config(), config_exports));
+    const cfg = getConfig2();
     const created = await sessionQueries.create({
       name: getDefaultOrchestratorName() || "Orchestrator",
       workingDirectory: cfg.resolvedWorkingDirectory,
@@ -14782,6 +14844,11 @@ function publicBase() {
   const cfg = getConfig();
   return cfg.server?.publicUrl?.replace(/\/$/, "") || `http://${cfg.server?.host || "127.0.0.1"}:${cfg.server?.port || 3141}`;
 }
+function webhookPrefix() {
+  const cfg = getConfig();
+  const token = cfg?.webhooks?.token;
+  return token ? `/w/${token}` : "/api";
+}
 integrations.get("/", async (c) => {
   const cfg = getConfig();
   return c.json({
@@ -14791,7 +14858,7 @@ integrations.get("/", async (c) => {
       botTokenSet: !!cfg?.slack?.botToken,
       signingSecretSet: !!cfg?.slack?.signingSecret,
       defaultOrchestratorName: cfg?.slack?.defaultOrchestratorName || null,
-      eventsUrl: `${publicBase()}/api/slack/events`,
+      eventsUrl: `${publicBase()}${webhookPrefix()}/slack/events`,
       allowedUsers: cfg?.slack?.allowedUsers ?? [],
       allowedChannels: cfg?.slack?.allowedChannels ?? [],
       allowDmsFromAnyone: cfg?.slack?.allowDmsFromAnyone !== false,
@@ -14884,7 +14951,7 @@ schedulesRouter.delete("/:id", async (c) => {
 });
 var webhooksRouter = new Hono8();
 function withUrl(row) {
-  return { ...row, url: `${publicBase()}/api/inbox/${row.token}` };
+  return { ...row, url: `${publicBase()}${webhookPrefix()}/inbox/${row.token}` };
 }
 webhooksRouter.get("/", async (c) => {
   const orcId = await getOrchestratorId();
@@ -14987,7 +15054,7 @@ mcpRouter.post("/:id/test", async (c) => {
 // src/server/auth/cf-access.ts
 init_config();
 import { createRemoteJWKSet, jwtVerify } from "jose";
-var EXEMPT_PATH_PREFIXES = ["/health", "/api/slack/events", "/api/inbox/"];
+var EXEMPT_PATH_PREFIXES = ["/health", "/api/slack/events", "/api/inbox/", "/w/"];
 var cachedJWKS = null;
 var cachedJWKSUrl = null;
 function getOrCreateJWKS(teamDomain) {
@@ -15512,13 +15579,23 @@ async function createApp(options = {}) {
   app.route("/sessions", terminals);
   app.route("/terminals", terminals);
   app.route("/tasks", tasks_default);
-  app.route("/api/slack", slack);
-  app.route("/api/inbox", inbox);
   app.route("/api/integrations", integrations);
   app.route("/api/schedules", schedulesRouter);
-  app.route("/api/webhooks", webhooksRouter);
   app.route("/api/orchestrator", orchestratorRouter);
   app.route("/api/mcp", mcpRouter);
+  app.route("/api/webhooks", webhooksRouter);
+  const config = getConfig();
+  const webhookToken = config?.webhooks?.token;
+  if (webhookToken) {
+    app.route(`/w/${webhookToken}/slack`, slack);
+    app.route(`/w/${webhookToken}/inbox`, inbox);
+    if (!options.quiet) {
+      console.log(`  \u2192 Public webhooks mounted at /w/${webhookToken.slice(0, 4)}\u2026/<service>`);
+    }
+  } else {
+    app.route("/api/slack", slack);
+    app.route("/api/inbox", inbox);
+  }
   app.get("/openapi.json", async (c) => {
     return c.json(generateOpenAPISpec());
   });
@@ -16703,13 +16780,19 @@ program.name("sparkecoder").description("AI coding agent - just type sparkecoder
   }
   await runChat(options);
 });
-program.command("server").description("Start the SparkECoder server (API + Web UI)").option("-p, --port <port>", "API server port", "3141").option("-h, --host <host>", "Server host", "127.0.0.1").option("-c, --config <path>", "Path to config file").option("-w, --working-dir <path>", "Working directory").option("--web-port <port>", "Web UI port", "6969").option("--no-web", "Do not start web UI").option("--public-url <url>", "Public URL for web UI to connect to API (for Docker/remote access)").option("-v, --verbose", "Enable verbose logging for web server").option("--enable-computer-use", "Enable the Anthropic computer use tool for all new sessions by default (macOS only)").action(async (options) => {
+program.command("server").description("Start the SparkECoder server (API + Web UI)").option("-p, --port <port>", "API server port", "3141").option("-h, --host <host>", "Server host", "127.0.0.1").option("-c, --config <path>", "Path to config file").option("-w, --working-dir <path>", "Working directory").option("--web-port <port>", "Web UI port", "6969").option("--no-web", "Do not start web UI").option("--public-url <url>", "Public URL for web UI to connect to API (for Docker/remote access)").option("-v, --verbose", "Enable verbose logging for web server").option("--enable-computer-use", "Enable the Anthropic computer use tool for all new sessions by default (macOS only)").option("--setup-secret <secret>", "Setup secret (or short-lived JWT) used for /auth/register and /tunnels when the remote server has SETUP_SECRET configured. Equivalent to setting SPARKECODER_SETUP_SECRET env.").action(async (options) => {
   const globalOpts = program.opts();
   const enableCU = options.enableComputerUse || globalOpts.enableComputerUse;
   if (enableCU) {
     process.env.SPARKECODER_COMPUTER_USE = "1";
     console.log(chalk.cyan("\u2192 Computer use enabled by default for new sessions."));
   }
+  if (options.setupSecret) {
+    process.env.SPARKECODER_SETUP_SECRET = options.setupSecret;
+    if (!process.env.SPARKECODER_TUNNEL_SECRET) {
+      process.env.SPARKECODER_TUNNEL_SECRET = options.setupSecret;
+    }
+  }
   await ensureDependencies({ quiet: false });
   const spinner = ora("Starting SparkECoder server...").start();
   try {
@@ -17004,10 +17087,24 @@ program.command("cloudflared-setup").description("Auto-detect cloudflared + set
         process.exitCode = 1;
         return;
       }
-      const { tunnelToken, hostname: provisionedHost, apiHostname, reused } = await res.json();
+      const { tunnelToken, hostname: provisionedHost, apiHostname, reused, webhookToken, webhookBaseUrl } = await res.json();
       if (reused) {
         console.log(chalk.dim("\u2713 Re-using existing tunnel \u2014 no new tunnel created on Cloudflare."));
       }
+      try {
+        setPublicUrl(`https://${apiHostname}`);
+        console.log(chalk.dim(`\u2713 Saved publicUrl = https://${apiHostname} into config.`));
+      } catch (err) {
+        console.warn(chalk.yellow(`Could not persist publicUrl: ${err?.message ?? err}`));
+      }
+      if (webhookToken) {
+        try {
+          setWebhookToken(webhookToken);
+          console.log(chalk.dim(`\u2713 Saved webhook prefix into config: ${webhookBaseUrl ?? `https://${apiHostname}/w/${webhookToken}`}`));
+        } catch (err) {
+          console.warn(chalk.yellow(`Could not persist webhook token: ${err?.message ?? err}`));
+        }
+      }
       const cfPath = await installCloudflaredIfNeeded();
       if (!cfPath) {
         console.log(chalk.yellow("cloudflared not installed; run this once installed:"));