@isarai/maestro 0.1.4 → 0.1.6

package/dist/server.js

@@ -828,10 +828,10 @@ var init_terminal_replica = __esm({
       }
       write(data, cursor) {
         return this.enqueue(
-          () => new Promise((resolve4) => {
+          () => new Promise((resolve5) => {
             this.terminal.write(data, () => {
               this.refreshSnapshot(cursor);
-              resolve4();
+              resolve5();
             });
           })
         );
@@ -849,8 +849,8 @@ var init_terminal_replica = __esm({
             this.terminal.resize(snapshot.cols, snapshot.rows);
           }
           if (snapshot.data) {
-            await new Promise((resolve4) => {
-              this.terminal.write(snapshot.data, resolve4);
+            await new Promise((resolve5) => {
+              this.terminal.write(snapshot.data, resolve5);
             });
           }
           this.refreshSnapshot(cursor);
@@ -1493,7 +1493,7 @@ function startCodexDeviceAuth() {
     activeCodexPty.kill();
     activeCodexPty = null;
   }
-  return new Promise((resolve4, reject) => {
+  return new Promise((resolve5, reject) => {
     const proc = pty2.spawn("codex", ["login", "--device-auth"], {
       name: "xterm-256color",
       cols: 120,
@@ -1510,7 +1510,7 @@ function startCodexDeviceAuth() {
       const codeMatch = clean.match(/one-time code[^\n]*\n\s+([A-Z0-9]+-[A-Z0-9]+)/i);
       if (codeMatch && urlMatch && !resolved) {
         resolved = true;
-        resolve4({ code: codeMatch[1], url: urlMatch[1] });
+        resolve5({ code: codeMatch[1], url: urlMatch[1] });
       }
     });
     proc.onExit(({ exitCode }) => {
@@ -3308,16 +3308,16 @@ function readCommandError(error, fallback) {
   }
   return error instanceof Error && error.message ? error.message : fallback;
 }
-function runGit2(path19, args) {
+function runGit2(path20, args) {
   return execFileSync6("git", args, {
-    cwd: path19,
+    cwd: path20,
     encoding: "utf8",
     stdio: ["ignore", "pipe", "pipe"]
   }).trim();
 }
-function tryRunGit(path19, args) {
+function tryRunGit(path20, args) {
   try {
-    return { ok: true, output: runGit2(path19, args) };
+    return { ok: true, output: runGit2(path20, args) };
   } catch (error) {
     return {
       ok: false,
@@ -3428,20 +3428,20 @@ function decideAutoWorktreeStartPoint(input) {
     reason: "Using local HEAD in a fresh worktree because no remote tracking branch was available."
   };
 }
-function resolveUpstreamRef(path19, currentBranch) {
-  const upstream = tryRunGit(path19, ["rev-parse", "--abbrev-ref", "@{upstream}"]);
+function resolveUpstreamRef(path20, currentBranch) {
+  const upstream = tryRunGit(path20, ["rev-parse", "--abbrev-ref", "@{upstream}"]);
   if (upstream.ok && upstream.output) {
     return upstream.output;
   }
   const originBranch = `refs/remotes/origin/${currentBranch}`;
-  const remoteBranch = tryRunGit(path19, ["show-ref", "--verify", "--quiet", originBranch]);
+  const remoteBranch = tryRunGit(path20, ["show-ref", "--verify", "--quiet", originBranch]);
   if (remoteBranch.ok) {
     return `origin/${currentBranch}`;
   }
   return null;
 }
-function hasGitRef(path19, ref) {
-  return tryRunGit(path19, ["show-ref", "--verify", "--quiet", ref]).ok;
+function hasGitRef(path20, ref) {
+  return tryRunGit(path20, ["show-ref", "--verify", "--quiet", ref]).ok;
 }
 async function resolveAutoWorktreeStartPoint(input) {
   const project = resolveProjectRecord(input);
@@ -3599,11 +3599,11 @@ function shouldDeleteTerminalDuringRestore(terminal) {
   );
 }
 function createExitWaiter() {
-  let resolve4 = () => void 0;
+  let resolve5 = () => void 0;
   const promise = new Promise((innerResolve) => {
-    resolve4 = innerResolve;
+    resolve5 = innerResolve;
   });
-  return { promise, resolve: resolve4 };
+  return { promise, resolve: resolve5 };
 }
 function getRuntime(terminalId) {
   let rt = agentRuntimes.get(terminalId);
@@ -3691,9 +3691,9 @@ function prepareExitWaiter(rt) {
   rt.resolveExit = waiter.resolve;
 }
 function resolveExitWaiter(rt) {
-  const resolve4 = rt.resolveExit;
+  const resolve5 = rt.resolveExit;
   rt.resolveExit = null;
-  resolve4?.();
+  resolve5?.();
 }
 function scheduleHistoryFlush(terminalId, rt) {
   if (rt.historyFlushTimer || !terminalCanUseRuntime(terminalId, rt)) {
@@ -4368,28 +4368,22 @@ var UpdateStatus = z.object({
   updating: z.boolean(),
   lastError: z.string().nullable()
 });
-var DeploymentReleaseInfo = z.object({
-  tag: z.string(),
-  name: z.string().nullable(),
-  url: z.string().nullable(),
-  publishedAt: z.string().nullable(),
-  notes: z.string().nullable()
-});
-var DeploymentUpdateStatus = z.object({
-  configured: z.boolean(),
+var MaestroInstallMode = z.enum(["npm", "container", "unknown"]);
+var MaestroUpdateStatus = z.object({
+  supported: z.boolean(),
+  installMode: MaestroInstallMode,
   currentVersion: z.string().nullable(),
   latestVersion: z.string().nullable(),
   updateAvailable: z.boolean(),
   updating: z.boolean(),
   lastCheckedAt: z.string().nullable(),
   lastUpdatedAt: z.string().nullable(),
-  lastError: z.string().nullable(),
-  latestRelease: DeploymentReleaseInfo.nullable()
+  lastError: z.string().nullable()
 });
-var DeploymentRedeployResponse = z.object({
+var MaestroUpdateTriggerResponse = z.object({
   accepted: z.boolean(),
-  targetVersion: z.string().nullable(),
-  message: z.string()
+  message: z.string(),
+  targetVersion: z.string().nullable()
 });
 
 // ../wire/src/agent.ts
@@ -6810,126 +6804,238 @@ async function registerSettingsRoutes(app) {
   });
 }
 
-// ../server/src/services/deployment-updater.ts
-function getUpdaterConfig() {
-  const url = process.env.UPDATER_URL?.trim();
-  const token = process.env.UPDATER_TOKEN?.trim();
-  if (!url) {
+// ../server/src/main.ts
+init_auth_status_checker();
+
+// ../server/src/routes/setup-routes.ts
+async function registerSetupRoutes(app) {
+  app.get("/api/setup/status", async () => ({
+    needsSetup: false,
+    running: false
+  }));
+  app.post("/api/setup/reset", async () => {
+    return { ok: true };
+  });
+}
+
+// ../server/src/services/maestro-updater.ts
+init_files();
+import * as fs15 from "node:fs";
+import * as os9 from "node:os";
+import * as path16 from "node:path";
+import { execFileSync as execFileSync8, spawn as spawn4 } from "node:child_process";
+var UPDATE_STATE_PATH = path16.join(os9.homedir(), ".maestro", "maestro-update-state.json");
+var LOG_PATH = path16.join(os9.homedir(), ".maestro", "server.log");
+var DEFAULT_STATE = {
+  updating: false,
+  lastCheckedAt: null,
+  lastUpdatedAt: null,
+  latestVersion: null,
+  lastError: null
+};
+function readState() {
+  return readJsonFile(UPDATE_STATE_PATH, DEFAULT_STATE);
+}
+function writeState(patch) {
+  const next = { ...readState(), ...patch };
+  writeJsonFile(UPDATE_STATE_PATH, next, { mode: 384 });
+  return next;
+}
+function nowIso2() {
+  return (/* @__PURE__ */ new Date()).toISOString();
+}
+function getInstallRoot() {
+  const raw = process.env.MAESTRO_INSTALL_ROOT;
+  if (!raw) return null;
+  const resolved = path16.resolve(raw);
+  return fs15.existsSync(path16.join(resolved, "package.json")) ? resolved : null;
+}
+function isContainerManagedInstall() {
+  return fs15.existsSync("/.dockerenv") || Boolean(process.env.KUBERNETES_SERVICE_HOST);
+}
+function getNpmCommand() {
+  return process.platform === "win32" ? "npm.cmd" : "npm";
+}
+function readPackageMeta(installRoot) {
+  try {
+    return JSON.parse(fs15.readFileSync(path16.join(installRoot, "package.json"), "utf8"));
+  } catch {
     return null;
   }
-  return {
-    url: url.replace(/\/+$/g, ""),
-    token: token || null
-  };
-}
-function getDisabledStatus(message) {
-  return {
-    configured: false,
-    currentVersion: null,
-    latestVersion: null,
-    updateAvailable: false,
-    updating: false,
-    lastCheckedAt: null,
-    lastUpdatedAt: null,
-    lastError: message ?? null,
-    latestRelease: null
-  };
 }
-async function requestUpdater(path19, init) {
-  const config = getUpdaterConfig();
-  if (!config) {
-    throw new Error("Deployment updater is not configured");
-  }
-  const res = await fetch(`${config.url}${path19}`, {
-    ...init,
-    headers: {
-      ...config.token ? { Authorization: `Bearer ${config.token}` } : {},
-      ...init?.body != null ? { "Content-Type": "application/json" } : {},
-      ...init?.headers
-    },
-    signal: AbortSignal.timeout(init?.timeoutMs ?? 15e3)
-  });
-  const body = await res.json().catch(() => ({}));
-  if (!res.ok) {
-    throw new Error(
-      typeof body.error === "string" ? body.error : `Updater request failed (${res.status})`
-    );
+function getGlobalNpmRoot(npmCommand) {
+  try {
+    return execFileSync8(npmCommand, ["root", "-g"], {
+      encoding: "utf8",
+      stdio: ["ignore", "pipe", "ignore"]
+    }).trim();
+  } catch {
+    return null;
   }
-  return body;
 }
-async function getDeploymentUpdateStatus() {
-  const config = getUpdaterConfig();
-  if (!config) {
-    return getDisabledStatus(
-      "Set UPDATER_URL on the Maestro server to enable release redeploys. UPDATER_TOKEN is optional on the internal network."
-    );
+function detectInstallMode() {
+  if (isContainerManagedInstall()) {
+    return { installMode: "container", installRoot: null, meta: null };
+  }
+  const installRoot = getInstallRoot();
+  const meta = installRoot ? readPackageMeta(installRoot) : null;
+  if (!installRoot || !meta) {
+    return { installMode: "unknown", installRoot: null, meta: null };
   }
+  const globalRoot = getGlobalNpmRoot(getNpmCommand());
+  if (!globalRoot) {
+    return { installMode: "unknown", installRoot, meta };
+  }
+  const expectedRoot = path16.resolve(globalRoot, meta.name);
+  if (path16.resolve(installRoot) !== expectedRoot) {
+    return { installMode: "unknown", installRoot, meta };
+  }
+  return { installMode: "npm", installRoot, meta };
+}
+function getLatestVersion2(packageName) {
   try {
-    return await requestUpdater("/status");
-  } catch (error) {
+    return execFileSync8(getNpmCommand(), ["view", `${packageName}@latest`, "version"], {
+      encoding: "utf8",
+      stdio: ["ignore", "pipe", "ignore"],
+      timeout: 6e4
+    }).trim() || null;
+  } catch {
+    return null;
+  }
+}
+async function checkForMaestroUpdates() {
+  const install = detectInstallMode();
+  if (install.installMode !== "npm" || !install.meta) {
+    const state2 = writeState({
+      updating: false,
+      lastCheckedAt: nowIso2(),
+      lastError: install.installMode === "container" ? "Maestro is container-managed. Redeploy the image instead of using self-update." : "Maestro self-update is only available for the published global npm install."
+    });
     return {
-      configured: true,
-      currentVersion: null,
-      latestVersion: null,
+      supported: false,
+      installMode: install.installMode,
+      currentVersion: install.meta?.version ?? null,
+      latestVersion: state2.latestVersion,
       updateAvailable: false,
       updating: false,
-      lastCheckedAt: null,
-      lastUpdatedAt: null,
-      lastError: error instanceof Error ? error.message : "Failed to reach the deployment updater",
-      latestRelease: null
+      lastCheckedAt: state2.lastCheckedAt,
+      lastUpdatedAt: state2.lastUpdatedAt,
+      lastError: state2.lastError
     };
   }
-}
-async function checkDeploymentUpdateStatus() {
-  const config = getUpdaterConfig();
-  if (!config) {
-    return getDisabledStatus(
-      "Set UPDATER_URL on the Maestro server to enable release redeploys. UPDATER_TOKEN is optional on the internal network."
-    );
-  }
-  return requestUpdater("/check", {
-    method: "POST"
+  const latestVersion = getLatestVersion2(install.meta.name);
+  const state = writeState({
+    lastCheckedAt: nowIso2(),
+    latestVersion,
+    lastError: latestVersion ? null : `Failed to query the latest published version for ${install.meta.name}.`
   });
+  return {
+    supported: true,
+    installMode: "npm",
+    currentVersion: install.meta.version,
+    latestVersion: state.latestVersion,
+    updateAvailable: state.latestVersion !== null && state.latestVersion !== install.meta.version,
+    updating: state.updating,
+    lastCheckedAt: state.lastCheckedAt,
+    lastUpdatedAt: state.lastUpdatedAt,
+    lastError: state.lastError
+  };
 }
-async function triggerDeploymentRedeploy(tag) {
-  return requestUpdater("/redeploy", {
-    method: "POST",
-    body: JSON.stringify(tag ? { tag } : {}),
-    timeoutMs: 3e4
-  });
+function getMaestroUpdateStatus() {
+  const install = detectInstallMode();
+  let state = readState();
+  const currentVersion = install.meta?.version ?? null;
+  if (state.updating && install.installMode === "npm" && currentVersion !== null && state.latestVersion !== null && currentVersion === state.latestVersion) {
+    state = writeState({
+      updating: false,
+      lastUpdatedAt: state.lastUpdatedAt ?? nowIso2(),
+      lastError: null
+    });
+  }
+  return {
+    supported: install.installMode === "npm",
+    installMode: install.installMode,
+    currentVersion,
+    latestVersion: state.latestVersion,
+    updateAvailable: install.installMode === "npm" && currentVersion !== null && state.latestVersion !== null && currentVersion !== state.latestVersion,
+    updating: state.updating,
+    lastCheckedAt: state.lastCheckedAt,
+    lastUpdatedAt: state.lastUpdatedAt,
+    lastError: state.lastError
+  };
 }
-
-// ../server/src/routes/deployment-routes.ts
-async function registerDeploymentRoutes(app) {
-  app.get("/api/deployment/update-status", async () => {
-    return getDeploymentUpdateStatus();
-  });
-  app.post("/api/deployment/check", async () => {
-    return checkDeploymentUpdateStatus();
+async function triggerMaestroUpdate() {
+  const status = await checkForMaestroUpdates();
+  if (!status.supported) {
+    return {
+      accepted: false,
+      message: status.lastError ?? "Maestro self-update is only available for the published global npm install.",
+      targetVersion: null
+    };
+  }
+  if (status.updating) {
+    return {
+      accepted: false,
+      message: "Maestro update already in progress.",
+      targetVersion: status.latestVersion
+    };
+  }
+  if (!status.updateAvailable || !status.latestVersion) {
+    return {
+      accepted: false,
+      message: "Maestro is already up to date.",
+      targetVersion: status.currentVersion
+    };
+  }
+  const installRoot = getInstallRoot();
+  if (!installRoot) {
+    return {
+      accepted: false,
+      message: "Failed to locate the installed Maestro CLI root.",
+      targetVersion: null
+    };
+  }
+  const cliEntry = path16.join(installRoot, "dist", "index.js");
+  if (!fs15.existsSync(cliEntry)) {
+    return {
+      accepted: false,
+      message: `Maestro CLI entrypoint not found at ${cliEntry}.`,
+      targetVersion: null
+    };
+  }
+  fs15.mkdirSync(path16.dirname(LOG_PATH), { recursive: true });
+  const out = fs15.openSync(LOG_PATH, "a");
+  writeState({
+    updating: true,
+    lastUpdatedAt: nowIso2(),
+    lastError: null
   });
-  app.post("/api/deployment/redeploy", async (req, reply) => {
-    try {
-      const body = req.body;
-      return await triggerDeploymentRedeploy(body?.tag);
-    } catch (error) {
-      const message = error instanceof Error ? error.message : "Failed to trigger redeploy";
-      const status = /not configured/i.test(message) || /missing/i.test(message) ? 400 : 502;
-      return reply.status(status).send({ error: message });
+  const child = spawn4(process.execPath, [cliEntry, "update"], {
+    detached: true,
+    stdio: ["ignore", out, out],
+    env: {
+      ...process.env,
+      MAESTRO_SELF_UPDATE_DELAY_MS: "1000"
     }
   });
+  child.unref();
+  return {
+    accepted: true,
+    message: `Started Maestro update to ${status.latestVersion}. The server connection will drop briefly while it restarts.`,
+    targetVersion: status.latestVersion
+  };
 }
 
-// ../server/src/main.ts
-init_auth_status_checker();
-
-// ../server/src/routes/setup-routes.ts
-async function registerSetupRoutes(app) {
-  app.get("/api/setup/status", async () => ({
-    needsSetup: false,
-    running: false
-  }));
-  app.post("/api/setup/reset", async () => {
-    return { ok: true };
+// ../server/src/routes/maestro-update-routes.ts
+async function registerMaestroUpdateRoutes(app) {
+  app.get("/api/maestro/update-status", async () => {
+    return getMaestroUpdateStatus();
+  });
+  app.post("/api/maestro/check", async () => {
+    return checkForMaestroUpdates();
+  });
+  app.post("/api/maestro/update", async () => {
+    return triggerMaestroUpdate();
   });
 }
 
@@ -6995,8 +7101,8 @@ You are a friendly, conversational AI assistant. You communicate via messaging (
 }
 
 // ../pi/src/channels/whatsapp/whatsapp.ts
-import * as os9 from "os";
-import * as path16 from "path";
+import * as os10 from "os";
+import * as path17 from "path";
 import makeWASocket, {
   useMultiFileAuthState,
   DisconnectReason,
@@ -7004,8 +7110,8 @@ import makeWASocket, {
   makeCacheableSignalKeyStore
 } from "@whiskeysockets/baileys";
 import * as QRCode from "qrcode";
-var DATA_DIR = path16.join(os9.homedir(), ".maestro");
-var AUTH_DIR = path16.join(DATA_DIR, "whatsapp-auth");
+var DATA_DIR = path17.join(os10.homedir(), ".maestro");
+var AUTH_DIR = path17.join(DATA_DIR, "whatsapp-auth");
 var sock = null;
 var io = null;
 var connectionStatus = "disconnected";
@@ -7159,14 +7265,14 @@ import {
 } from "@mariozechner/pi-coding-agent";
 
 // ../pi/src/channels/whatsapp/store.ts
-import * as fs15 from "fs";
-import * as os10 from "os";
-import * as path17 from "path";
+import * as fs16 from "fs";
+import * as os11 from "os";
+import * as path18 from "path";
 import { randomUUID as randomUUID5 } from "crypto";
 import { DatabaseSync as DatabaseSync2 } from "node:sqlite";
-var DATA_DIR2 = path17.join(os10.homedir(), ".maestro");
-fs15.mkdirSync(DATA_DIR2, { recursive: true });
-var dbPath2 = path17.join(DATA_DIR2, "pi.sqlite");
+var DATA_DIR2 = path18.join(os11.homedir(), ".maestro");
+fs16.mkdirSync(DATA_DIR2, { recursive: true });
+var dbPath2 = path18.join(DATA_DIR2, "pi.sqlite");
 var db2 = new DatabaseSync2(dbPath2);
 db2.exec(`
   CREATE TABLE IF NOT EXISTS whatsapp_messages (
@@ -7185,7 +7291,7 @@ db2.exec(`
   CREATE INDEX IF NOT EXISTS idx_wa_status ON whatsapp_messages(status);
   CREATE INDEX IF NOT EXISTS idx_wa_chat ON whatsapp_messages(chat_jid, created_at);
 `);
-function nowIso2() {
+function nowIso3() {
   return (/* @__PURE__ */ new Date()).toISOString();
 }
 function toWhatsAppMessage(row) {
@@ -7205,7 +7311,7 @@ function toWhatsAppMessage(row) {
 }
 function insertWhatsAppMessage(input) {
   const id = randomUUID5();
-  const now = nowIso2();
+  const now = nowIso3();
   const status = input.status ?? "queued";
   db2.prepare(`
     INSERT INTO whatsapp_messages (id, chat_jid, message_id, direction, sender_name, body, status, created_at)
@@ -7270,7 +7376,7 @@ var session = null;
 var isProcessing = false;
 var PI_PROJECT_PATH = process.env.PI_PROJECT_PATH || "/tmp/maestro-whatsapp";
 var PI_TIMEOUT_MS = parseInt(process.env.PI_TIMEOUT_MS || "300000", 10);
-function nowIso3() {
+function nowIso4() {
   return (/* @__PURE__ */ new Date()).toISOString();
 }
 async function ensureSession() {
@@ -7304,7 +7410,7 @@ async function ensureSession() {
   return s;
 }
 function sendPrompt(s, message) {
-  return new Promise((resolve4, reject) => {
+  return new Promise((resolve5, reject) => {
     let responseText = "";
     let done = false;
     const timer4 = setTimeout(() => {
@@ -7328,7 +7434,7 @@ function sendPrompt(s, message) {
           reject(new Error(lastAssistant.errorMessage));
           return;
         }
-        resolve4(responseText.trim() || "Agent completed without text output.");
+        resolve5(responseText.trim() || "Agent completed without text output.");
       }
     });
     s.prompt(message).catch((err) => {
@@ -7378,7 +7484,7 @@ async function processNext() {
     if (msg.body.trim().toLowerCase() === "reset") {
       await s.newSession();
       await sendWhatsAppMessage(msg.chatJid, "Session reset.");
-      updateWhatsAppMessage(msg.id, { status: "completed", responseText: "Session reset.", processedAt: nowIso3() });
+      updateWhatsAppMessage(msg.id, { status: "completed", responseText: "Session reset.", processedAt: nowIso4() });
       console.log("[whatsapp-queue] Session reset by user");
       return;
     }
@@ -7395,7 +7501,7 @@ async function processNext() {
     updateWhatsAppMessage(msg.id, {
       status: "completed",
       responseText,
-      processedAt: nowIso3()
+      processedAt: nowIso4()
     });
     console.log(`[whatsapp-queue] Completed message ${msg.id}`);
   } catch (error) {
@@ -7404,7 +7510,7 @@ async function processNext() {
     updateWhatsAppMessage(msg.id, {
       status: "failed",
       error: errMsg,
-      processedAt: nowIso3()
+      processedAt: nowIso4()
     });
   } finally {
     isProcessing = false;
@@ -7581,14 +7687,14 @@ import {
 } from "@mariozechner/pi-coding-agent";
 
 // ../pi/src/channels/telegram/store.ts
-import * as fs16 from "fs";
-import * as os11 from "os";
-import * as path18 from "path";
+import * as fs17 from "fs";
+import * as os12 from "os";
+import * as path19 from "path";
 import { randomUUID as randomUUID6 } from "crypto";
 import { DatabaseSync as DatabaseSync3 } from "node:sqlite";
-var DATA_DIR3 = path18.join(os11.homedir(), ".maestro");
-fs16.mkdirSync(DATA_DIR3, { recursive: true });
-var dbPath3 = path18.join(DATA_DIR3, "pi.sqlite");
+var DATA_DIR3 = path19.join(os12.homedir(), ".maestro");
+fs17.mkdirSync(DATA_DIR3, { recursive: true });
+var dbPath3 = path19.join(DATA_DIR3, "pi.sqlite");
 var db3 = new DatabaseSync3(dbPath3);
 db3.exec(`
   CREATE TABLE IF NOT EXISTS telegram_messages (
@@ -7607,7 +7713,7 @@ db3.exec(`
   CREATE INDEX IF NOT EXISTS idx_tg_status ON telegram_messages(status);
   CREATE INDEX IF NOT EXISTS idx_tg_chat ON telegram_messages(chat_id, created_at);
 `);
-function nowIso4() {
+function nowIso5() {
   return (/* @__PURE__ */ new Date()).toISOString();
 }
 function toTelegramMessage(row) {
@@ -7627,7 +7733,7 @@ function toTelegramMessage(row) {
 }
 function insertTelegramMessage(input) {
   const id = randomUUID6();
-  const now = nowIso4();
+  const now = nowIso5();
   const status = input.status ?? "queued";
   db3.prepare(`
     INSERT INTO telegram_messages (id, chat_id, message_id, direction, sender_name, body, status, created_at)
@@ -7692,7 +7798,7 @@ var session2 = null;
 var isProcessing2 = false;
 var PI_PROJECT_PATH2 = process.env.PI_PROJECT_PATH || "/tmp/maestro-telegram";
 var PI_TIMEOUT_MS2 = parseInt(process.env.PI_TIMEOUT_MS || "300000", 10);
-function nowIso5() {
+function nowIso6() {
   return (/* @__PURE__ */ new Date()).toISOString();
 }
 async function ensureSession2() {
@@ -7726,7 +7832,7 @@ async function ensureSession2() {
   return s;
 }
 function sendPrompt2(s, message) {
-  return new Promise((resolve4, reject) => {
+  return new Promise((resolve5, reject) => {
     let responseText = "";
     let done = false;
     const timer4 = setTimeout(() => {
@@ -7750,7 +7856,7 @@ function sendPrompt2(s, message) {
           reject(new Error(lastAssistant.errorMessage));
           return;
         }
-        resolve4(responseText.trim() || "Agent completed without text output.");
+        resolve5(responseText.trim() || "Agent completed without text output.");
       }
     });
     s.prompt(message).catch((err) => {
@@ -7800,7 +7906,7 @@ async function processNext2() {
     if (msg.body.trim().toLowerCase() === "reset") {
       await s.newSession();
       await sendTelegramMessage(msg.chatId, "Session reset.");
-      updateTelegramMessage(msg.id, { status: "completed", responseText: "Session reset.", processedAt: nowIso5() });
+      updateTelegramMessage(msg.id, { status: "completed", responseText: "Session reset.", processedAt: nowIso6() });
       console.log("[telegram-queue] Session reset by user");
       return;
     }
@@ -7817,7 +7923,7 @@ async function processNext2() {
     updateTelegramMessage(msg.id, {
       status: "completed",
       responseText,
-      processedAt: nowIso5()
+      processedAt: nowIso6()
     });
     console.log(`[telegram-queue] Completed message ${msg.id}`);
   } catch (error) {
@@ -7826,7 +7932,7 @@ async function processNext2() {
     updateTelegramMessage(msg.id, {
       status: "failed",
       error: errMsg,
-      processedAt: nowIso5()
+      processedAt: nowIso6()
     });
   } finally {
     isProcessing2 = false;
@@ -7924,7 +8030,7 @@ async function main() {
   await registerGitHubIntegrationRoutes(app);
   await registerWebhookRoutes(app, io3);
   await registerSettingsRoutes(app);
-  await registerDeploymentRoutes(app);
+  await registerMaestroUpdateRoutes(app);
   await registerSetupRoutes(app);
   await registerWhatsAppRoutes(app, io3);
   await registerTelegramRoutes(app, io3, () => getSettings().telegramBotToken);