sparkecoder 0.1.131 → 0.1.133

package/dist/index.js

@@ -649,12 +649,12 @@ function loadConfig(configPath, workingDirectory) {
     ]
   };
   const DEFAULT_REMOTE_URL = "https://agent-remote-server.sparkecode.com";
-  const remoteUrl = process.env.SPARKECODER_REMOTE_URL || config.remoteServer?.url || DEFAULT_REMOTE_URL;
+  const remoteUrl2 = process.env.SPARKECODER_REMOTE_URL || config.remoteServer?.url || DEFAULT_REMOTE_URL;
   const remoteAuthKey = process.env.SPARKECODER_AUTH_KEY || config.remoteServer?.authKey || loadStoredAuthKey();
   const resolvedRemoteServer = {
-    url: remoteUrl,
+    url: remoteUrl2,
     authKey: remoteAuthKey,
-    isConfigured: !!remoteUrl && !!remoteAuthKey
+    isConfigured: !!remoteUrl2 && !!remoteAuthKey
   };
   const resolved = {
     ...config,
@@ -4910,11 +4910,11 @@ async function getRepoNamespace(workingDirectory, configuredNamespace) {
   if (configuredNamespace) {
     return configuredNamespace;
   }
-  const remoteUrl = getGitRemoteUrl(workingDirectory);
-  if (!remoteUrl) {
+  const remoteUrl2 = getGitRemoteUrl(workingDirectory);
+  if (!remoteUrl2) {
     return null;
   }
-  const parsed = parseGitRemoteUrl(remoteUrl);
+  const parsed = parseGitRemoteUrl(remoteUrl2);
   if (!parsed) {
     return null;
   }
@@ -8362,6 +8362,29 @@ var init_persistence = __esm({
 });
 
 // src/integrations/slack/client.ts
+var client_exports = {};
+__export(client_exports, {
+  LOADING_REACTION: () => LOADING_REACTION,
+  RESULT_REACTIONS: () => RESULT_REACTIONS,
+  addLoadingReaction: () => addLoadingReaction,
+  addResultReaction: () => addResultReaction,
+  botParticipatedInThread: () => botParticipatedInThread,
+  ensureSlackSelfIdentity: () => ensureSlackSelfIdentity,
+  getCachedSlackSelfIdentity: () => getCachedSlackSelfIdentity,
+  getDefaultOrchestratorName: () => getDefaultOrchestratorName,
+  getSlackAdapter: () => getSlackAdapter,
+  getSlackAllowlistPolicy: () => getSlackAllowlistPolicy,
+  getSlackBotToken: () => getSlackBotToken,
+  getSlackDeniedReplyPolicy: () => getSlackDeniedReplyPolicy,
+  getSlackSigningSecret: () => getSlackSigningSecret,
+  isSlackConfigured: () => isSlackConfigured,
+  normalizeSlackMentions: () => normalizeSlackMentions,
+  noteBotPostedInThread: () => noteBotPostedInThread,
+  postThreadMessage: () => postThreadMessage,
+  removeLoadingReaction: () => removeLoadingReaction,
+  resolveSlackUserInfo: () => resolveSlackUserInfo,
+  resolveSlackUserName: () => resolveSlackUserName
+});
 function slackBackoffMs(attempt) {
   const expo = SLACK_BACKOFF_BASE_MS * 2 ** attempt;
   const jitter = Math.floor(Math.random() * SLACK_BACKOFF_BASE_MS);
@@ -11678,11 +11701,11 @@ ${p.text}` : p.text;
           const { isRemoteConfigured: isRemoteConfigured2, storageQueries: storageQueries2 } = await Promise.resolve().then(() => (init_remote(), remote_exports));
           if (!isRemoteConfigured2()) return [];
           const { readFile: readFile13 } = await import("fs/promises");
-          const { join: join19, basename: basename7 } = await import("path");
+          const { join: join20, basename: basename7 } = await import("path");
           const urls = [];
           for (const filePath of filePaths) {
             try {
-              const fullPath = filePath.startsWith("/") ? filePath : join19(this.session.workingDirectory, filePath);
+              const fullPath = filePath.startsWith("/") ? filePath : join20(this.session.workingDirectory, filePath);
               const fileName = basename7(fullPath);
               const ext = fileName.split(".").pop()?.toLowerCase() || "";
               const mimeMap = {
@@ -12053,6 +12076,233 @@ var init_ensure_orchestrator = __esm({
   }
 });
 
+// src/orchestrator/self-update.ts
+var self_update_exports = {};
+__export(self_update_exports, {
+  __test: () => __test,
+  startSelfUpdater: () => startSelfUpdater,
+  stopSelfUpdater: () => stopSelfUpdater
+});
+import { spawn as spawn2, execFile } from "child_process";
+import { readFileSync as readFileSync11, writeFileSync as writeFileSync7, mkdirSync as mkdirSync10 } from "fs";
+import { dirname as dirname10, join as join18 } from "path";
+import { fileURLToPath as fileURLToPath4 } from "url";
+function currentVersion2() {
+  const here = dirname10(fileURLToPath4(import.meta.url));
+  const candidates = [
+    join18(here, "..", "..", "package.json"),
+    join18(here, "..", "package.json"),
+    join18(process.cwd(), "package.json")
+  ];
+  for (const p of candidates) {
+    try {
+      const pkg = JSON.parse(readFileSync11(p, "utf8"));
+      if (pkg.name === "sparkecoder" && pkg.version) return pkg.version;
+    } catch {
+    }
+  }
+  return "0.0.0";
+}
+function isLikelyGlobalInstall() {
+  const here = dirname10(fileURLToPath4(import.meta.url));
+  return here.includes("/node_modules/sparkecoder/") || here.includes("\\node_modules\\sparkecoder\\");
+}
+function isEnabled() {
+  if (process.env.SPARKECODER_AUTO_UPDATE === "false" || process.env.SPARKECODER_AUTO_UPDATE === "0") return false;
+  try {
+    const cfg = getConfig();
+    if (cfg?.autoUpdate?.enabled === false) return false;
+  } catch {
+  }
+  return true;
+}
+function remoteUrl() {
+  try {
+    const cfg = getConfig();
+    const url = cfg?.remoteServer?.url;
+    return typeof url === "string" && url.length > 0 ? url.replace(/\/+$/, "") : null;
+  } catch {
+    return null;
+  }
+}
+function intervalMs() {
+  try {
+    const h = getConfig()?.autoUpdate?.intervalHours;
+    if (typeof h === "number" && h > 0) return h * 60 * 6e4;
+  } catch {
+  }
+  return DEFAULT_INTERVAL_HOURS * 60 * 6e4;
+}
+function semverGt(a, b) {
+  const parse = (v) => v.split("-")[0].split(".").map((n) => parseInt(n, 10) || 0);
+  const pa = parse(a);
+  const pb = parse(b);
+  for (let i = 0; i < Math.max(pa.length, pb.length); i++) {
+    const x = pa[i] ?? 0;
+    const y = pb[i] ?? 0;
+    if (x > y) return true;
+    if (x < y) return false;
+  }
+  return false;
+}
+function statePath() {
+  try {
+    return join18(getAppDataDirectory(), "self-update-state.json");
+  } catch {
+    return null;
+  }
+}
+function readState() {
+  const p = statePath();
+  if (!p) return {};
+  try {
+    return JSON.parse(readFileSync11(p, "utf8"));
+  } catch {
+    return {};
+  }
+}
+function writeState(s) {
+  const p = statePath();
+  if (!p) return;
+  try {
+    mkdirSync10(dirname10(p), { recursive: true });
+    writeFileSync7(p, JSON.stringify(s));
+  } catch {
+  }
+}
+function attemptedRecently(target, now) {
+  const s = readState();
+  return s.lastTarget === target && typeof s.lastAttemptAt === "number" && now - s.lastAttemptAt < RETRY_COOLDOWN_MS;
+}
+function latestPublishedVersion() {
+  return new Promise((resolve13) => {
+    execFile("npm", ["view", "sparkecoder", "version"], { timeout: 3e4 }, (err, stdout) => {
+      if (err) {
+        resolve13(null);
+        return;
+      }
+      const v = String(stdout).trim();
+      resolve13(/^\d+\.\d+\.\d+/.test(v) ? v : null);
+    });
+  });
+}
+function runInstaller(url) {
+  const secret = process.env.SPARKECODER_SETUP_SECRET || process.env.SPARKECODER_TUNNEL_SECRET || "";
+  const query = secret ? `?secret=${encodeURIComponent(secret)}` : "";
+  const oneLiner = `bash -c "$(curl -fsSL '${url}/install.sh${query}')" >/tmp/sparkecoder-selfupdate.log 2>&1`;
+  const child = spawn2("bash", ["-lc", oneLiner], {
+    detached: true,
+    stdio: "ignore"
+  });
+  child.unref();
+}
+async function checkAndUpdate() {
+  if (upgrading || !isEnabled()) return;
+  const url = remoteUrl();
+  if (!url) return;
+  const latest = await latestPublishedVersion();
+  if (!latest) return;
+  const current = currentVersion2();
+  if (!semverGt(latest, current)) return;
+  const now = Date.now();
+  if (attemptedRecently(latest, now)) {
+    console.log(`[self-update] v${latest} already attempted recently; skipping until cooldown elapses`);
+    return;
+  }
+  upgrading = true;
+  const announced = await announceUpdate(latest);
+  const delay = announced ? ANNOUNCE_GRACE_MS : 0;
+  if (announced) {
+    console.log(`[self-update] announced v${latest} in Slack; updating in ${Math.round(delay / 6e4)}m`);
+  }
+  const t = setTimeout(() => doInstall(latest, url, current), delay);
+  if (typeof t.unref === "function") t.unref();
+}
+function doInstall(latest, url, current) {
+  const prev = readState();
+  writeState({
+    lastTarget: latest,
+    lastAttemptAt: Date.now(),
+    attempts: prev.lastTarget === latest ? (prev.attempts ?? 0) + 1 : 1
+  });
+  console.log(`[self-update] newer version available: v${current} \u2192 v${latest}; re-running installer`);
+  try {
+    runInstaller(url);
+  } catch (err) {
+    upgrading = false;
+    console.warn("[self-update] failed to launch installer:", err?.message || err);
+  }
+}
+async function findOrchestratorId() {
+  try {
+    const { sessionQueries: sessionQueries2 } = await Promise.resolve().then(() => (init_db(), db_exports));
+    const all = await sessionQueries2.list(500, 0);
+    const orch = all.find((s) => s?.config?.role === "orchestrator");
+    return orch?.id ?? null;
+  } catch {
+    return null;
+  }
+}
+async function announceUpdate(target) {
+  try {
+    const { isSlackConfigured: isSlackConfigured2 } = await Promise.resolve().then(() => (init_client3(), client_exports));
+    if (!isSlackConfigured2()) return false;
+    const orchId = await findOrchestratorId();
+    if (!orchId) return false;
+    const { pushToInbox: pushToInbox2 } = await Promise.resolve().then(() => (init_inbox(), inbox_exports));
+    pushToInbox2(orchId, {
+      ref: { channel: "system", kind: "worker.completed", workerId: "self-update", workerName: "self-update" },
+      content: `[SYSTEM self-update] A software update to v${target} will begin in about 5 minutes and the service will restart briefly (expect ~1\u20132 minutes of downtime). Send a short Slack heads-up to whoever you normally talk to / the bot owner that you'll be offline for a quick update, then carry on. Use the messenger tool to deliver it. If you genuinely don't know who to tell, post in the most relevant channel you've recently been active in; if Slack isn't reachable, skip silently \u2014 the update will proceed regardless.`,
+      wake: "now",
+      enqueuedAt: /* @__PURE__ */ new Date()
+    });
+    return true;
+  } catch {
+    return false;
+  }
+}
+function startSelfUpdater() {
+  if (started) return;
+  started = true;
+  if (!isEnabled()) {
+    console.log("[self-update] disabled");
+    return;
+  }
+  if (!isLikelyGlobalInstall()) {
+    console.log("[self-update] skipped (not a global install)");
+    return;
+  }
+  const kickoff = setTimeout(() => {
+    void checkAndUpdate();
+    timer = setInterval(() => {
+      void checkAndUpdate();
+    }, intervalMs());
+    if (typeof timer.unref === "function") timer.unref();
+  }, INITIAL_DELAY_MS);
+  if (typeof kickoff.unref === "function") kickoff.unref();
+}
+function stopSelfUpdater() {
+  if (timer) {
+    clearInterval(timer);
+    timer = null;
+  }
+}
+var INITIAL_DELAY_MS, DEFAULT_INTERVAL_HOURS, ANNOUNCE_GRACE_MS, RETRY_COOLDOWN_MS, timer, started, upgrading, __test;
+var init_self_update = __esm({
+  "src/orchestrator/self-update.ts"() {
+    "use strict";
+    init_config();
+    INITIAL_DELAY_MS = 5 * 6e4;
+    DEFAULT_INTERVAL_HOURS = 6;
+    ANNOUNCE_GRACE_MS = 5 * 6e4;
+    RETRY_COOLDOWN_MS = 24 * 60 * 6e4;
+    timer = null;
+    started = false;
+    upgrading = false;
+    __test = { currentVersion: currentVersion2, semverGt, isLikelyGlobalInstall };
+  }
+});
+
 // src/tasks/scheduler.ts
 var scheduler_exports = {};
 __export(scheduler_exports, {
@@ -12139,11 +12389,11 @@ import { Hono as Hono10 } from "hono";
 import { serve } from "@hono/node-server";
 import { cors } from "hono/cors";
 import { logger } from "hono/logger";
-import { existsSync as existsSync22, mkdirSync as mkdirSync10, writeFileSync as writeFileSync7 } from "fs";
-import { resolve as resolve12, dirname as dirname10, join as join18 } from "path";
-import { spawn as spawn2 } from "child_process";
+import { existsSync as existsSync22, mkdirSync as mkdirSync11, writeFileSync as writeFileSync8 } from "fs";
+import { resolve as resolve12, dirname as dirname11, join as join19 } from "path";
+import { spawn as spawn3 } from "child_process";
 import { createServer as createNetServer } from "net";
-import { fileURLToPath as fileURLToPath4 } from "url";
+import { fileURLToPath as fileURLToPath5 } from "url";
 
 // src/server/routes/sessions.ts
 init_db();
@@ -16526,13 +16776,13 @@ var DEFAULT_WEB_PORT = 6969;
 var WEB_PORT_SEQUENCE = [6969, 6970, 6971, 6972, 6973, 6974, 6975, 6976, 6977, 6978];
 function getWebDirectory() {
   try {
-    const currentDir = dirname10(fileURLToPath4(import.meta.url));
+    const currentDir = dirname11(fileURLToPath5(import.meta.url));
     const webDir = resolve12(currentDir, "..", "web");
-    if (existsSync22(webDir) && existsSync22(join18(webDir, "package.json"))) {
+    if (existsSync22(webDir) && existsSync22(join19(webDir, "package.json"))) {
       return webDir;
     }
     const altWebDir = resolve12(currentDir, "..", "..", "web");
-    if (existsSync22(altWebDir) && existsSync22(join18(altWebDir, "package.json"))) {
+    if (existsSync22(altWebDir) && existsSync22(join19(altWebDir, "package.json"))) {
       return altWebDir;
     }
     return null;
@@ -16590,20 +16840,20 @@ async function findWebPort(preferredPort) {
   return { port: preferredPort, alreadyRunning: false };
 }
 function hasProductionBuild(webDir) {
-  const buildIdPath = join18(webDir, ".next", "BUILD_ID");
+  const buildIdPath = join19(webDir, ".next", "BUILD_ID");
   return existsSync22(buildIdPath);
 }
 function hasSourceFiles(webDir) {
-  const appDir = join18(webDir, "src", "app");
-  const pagesDir = join18(webDir, "src", "pages");
-  const rootAppDir = join18(webDir, "app");
-  const rootPagesDir = join18(webDir, "pages");
+  const appDir = join19(webDir, "src", "app");
+  const pagesDir = join19(webDir, "src", "pages");
+  const rootAppDir = join19(webDir, "app");
+  const rootPagesDir = join19(webDir, "pages");
   return existsSync22(appDir) || existsSync22(pagesDir) || existsSync22(rootAppDir) || existsSync22(rootPagesDir);
 }
 function getStandaloneServerPath(webDir) {
   const possiblePaths2 = [
-    join18(webDir, ".next", "standalone", "server.js"),
-    join18(webDir, ".next", "standalone", "web", "server.js")
+    join19(webDir, ".next", "standalone", "server.js"),
+    join19(webDir, ".next", "standalone", "web", "server.js")
   ];
   for (const serverPath of possiblePaths2) {
     if (existsSync22(serverPath)) {
@@ -16614,7 +16864,7 @@ function getStandaloneServerPath(webDir) {
 }
 function runCommand(command, args, cwd, env) {
   return new Promise((resolve13) => {
-    const child = spawn2(command, args, {
+    const child = spawn3(command, args, {
       cwd,
       stdio: ["ignore", "pipe", "pipe"],
       env,
@@ -16646,15 +16896,15 @@ async function startWebUI(apiPort, webPort = DEFAULT_WEB_PORT, quiet = false, pu
     if (!quiet) console.log(`  \u2713 Web UI already running at http://localhost:${actualPort}`);
     return { process: null, port: actualPort };
   }
-  const usePnpm = existsSync22(join18(webDir, "pnpm-lock.yaml"));
-  const useNpm = !usePnpm && existsSync22(join18(webDir, "package-lock.json"));
+  const usePnpm = existsSync22(join19(webDir, "pnpm-lock.yaml"));
+  const useNpm = !usePnpm && existsSync22(join19(webDir, "package-lock.json"));
   const pkgManager = usePnpm ? "pnpm" : useNpm ? "npm" : "npx";
   const { NODE_OPTIONS, TSX_TSCONFIG_PATH, ...cleanEnv } = process.env;
   const apiUrl = publicUrl || `http://127.0.0.1:${apiPort}`;
-  const runtimeConfig = { apiBaseUrl: apiUrl };
-  const runtimeConfigPath = join18(webDir, "runtime-config.json");
+  const runtimeConfig = { apiBaseUrl: apiUrl, localApiBaseUrl: `http://127.0.0.1:${apiPort}` };
+  const runtimeConfigPath = join19(webDir, "runtime-config.json");
   try {
-    writeFileSync7(runtimeConfigPath, JSON.stringify(runtimeConfig, null, 2));
+    writeFileSync8(runtimeConfigPath, JSON.stringify(runtimeConfig, null, 2));
     if (!quiet) console.log(`  \u{1F4DD} Runtime config written to ${runtimeConfigPath}`);
   } catch (err) {
     if (!quiet) console.warn(`  \u26A0 Could not write runtime config: ${err}`);
@@ -16674,7 +16924,7 @@ async function startWebUI(apiPort, webPort = DEFAULT_WEB_PORT, quiet = false, pu
   if (standaloneServerPath) {
     command = "node";
     args = ["server.js"];
-    cwd = dirname10(standaloneServerPath);
+    cwd = dirname11(standaloneServerPath);
     webEnv.PORT = String(actualPort);
     webEnv.HOSTNAME = "0.0.0.0";
     if (!quiet) console.log("  \u{1F4E6} Starting Web UI from standalone build...");
@@ -16704,7 +16954,7 @@ async function startWebUI(apiPort, webPort = DEFAULT_WEB_PORT, quiet = false, pu
     }
     return { process: null, port: actualPort };
   }
-  const child = spawn2(command, args, {
+  const child = spawn3(command, args, {
     cwd,
     stdio: ["ignore", "pipe", "pipe"],
     env: webEnv,
@@ -16712,12 +16962,12 @@ async function startWebUI(apiPort, webPort = DEFAULT_WEB_PORT, quiet = false, pu
     shell: true
   });
   const startupTimeout = 3e4;
-  let started = false;
+  let started2 = false;
   let exited = false;
   let exitCode = null;
   const startedPromise = new Promise((resolve13) => {
     const timeout = setTimeout(() => {
-      if (!started && !exited) {
+      if (!started2 && !exited) {
         resolve13(false);
       }
     }, startupTimeout);
@@ -16729,8 +16979,8 @@ async function startWebUI(apiPort, webPort = DEFAULT_WEB_PORT, quiet = false, pu
           console.log(`  Web UI: ${line}`);
         }
       }
-      if (!started && (output.includes("Ready") || output.includes("started") || output.includes("localhost"))) {
-        started = true;
+      if (!started2 && (output.includes("Ready") || output.includes("started") || output.includes("localhost"))) {
+        started2 = true;
         clearTimeout(timeout);
         resolve13(true);
       }
@@ -16749,7 +16999,7 @@ async function startWebUI(apiPort, webPort = DEFAULT_WEB_PORT, quiet = false, pu
     child.on("exit", (code) => {
       exited = true;
       exitCode = code;
-      if (!started) {
+      if (!started2) {
         clearTimeout(timeout);
         resolve13(false);
       }
@@ -16869,7 +17119,7 @@ async function startServer(options = {}) {
     config.resolvedWorkingDirectory = options.workingDirectory;
   }
   if (!existsSync22(config.resolvedWorkingDirectory)) {
-    mkdirSync10(config.resolvedWorkingDirectory, { recursive: true });
+    mkdirSync11(config.resolvedWorkingDirectory, { recursive: true });
     if (!options.quiet) console.log(`\u{1F4C1} Created agent workspace: ${config.resolvedWorkingDirectory}`);
   }
   if (!config.resolvedRemoteServer.url) {
@@ -16905,6 +17155,12 @@ async function startServer(options = {}) {
   } catch (err) {
     if (!options.quiet) console.warn(`[daemon] start skipped: ${err.message}`);
   }
+  try {
+    const { startSelfUpdater: startSelfUpdater2 } = await Promise.resolve().then(() => (init_self_update(), self_update_exports));
+    startSelfUpdater2();
+  } catch (err) {
+    if (!options.quiet) console.warn(`[self-update] start skipped: ${err.message}`);
+  }
   try {
     const { startScheduler: startScheduler2 } = await Promise.resolve().then(() => (init_scheduler(), scheduler_exports));
     startScheduler2({ quiet: options.quiet });