jeo-code 0.11.2 → 0.11.3

package/src/agent/notify/daemon-control.ts

@@ -15,6 +15,8 @@ import { readGlobalConfig } from "../state";
 export interface DaemonLockInfo {
   pid: number;
   startedAt: number;
+  purpose?: "daemon" | "pairing";
+  ready?: boolean;
 }
 
 export function isPidAlive(pid: number): boolean {
@@ -152,32 +154,87 @@ export async function readDaemonLock(): Promise<DaemonLockInfo | undefined> {
     const raw = await fs.readFile(notifyDaemonLockPath(), "utf-8");
     const parsed = JSON.parse(raw) as Partial<DaemonLockInfo>;
     if (typeof parsed.pid !== "number" || typeof parsed.startedAt !== "number") return undefined;
-    return { pid: parsed.pid, startedAt: parsed.startedAt };
+    if (!Number.isSafeInteger(parsed.pid) || parsed.pid <= 0 || !Number.isFinite(parsed.startedAt)) return undefined;
+    return { pid: parsed.pid, startedAt: parsed.startedAt, purpose: parsed.purpose, ready: parsed.ready };
   } catch {
     return undefined;
   }
 }
 
-/** Called by the daemon process itself on startup. Returns `undefined` when a
- *  live owner already holds the lock (caller must exit without polling
- *  Telegram); otherwise writes the lock and returns a `release()` closure. */
-export async function acquireDaemonLock(): Promise<{ release: () => Promise<void> } | undefined> {
+async function interruptedRecoveryMessage(): Promise<string | undefined> {
+  const guard = `${notifyDaemonLockPath()}.reclaim`;
+  const stat = await fs.stat(guard).catch(() => undefined);
+  if (stat && Date.now() - stat.mtimeMs >= 30_000) {
+    return `Notification lock recovery is blocked by ${guard}. Stop all daemon/pairing processes and verify their owners are gone before manually removing this recovery guard; it is not automatically deleted because that can race a live lock owner.`;
+  }
+  return undefined;
+}
+
+/** Exclusive process lock shared with Telegram pairing, which also owns getUpdates. */
+export async function acquireDaemonLock(purpose: "daemon" | "pairing" = "daemon"): Promise<{ release: () => Promise<void>; markReady: () => Promise<void> } | undefined> {
   await fs.mkdir(notifyDir(), { recursive: true, mode: 0o700 });
-  const existing = await readDaemonLock();
-  if (existing && existing.pid !== process.pid && (await isLockOwnerAlive(existing))) return undefined;
-  const info: DaemonLockInfo = { pid: process.pid, startedAt: Date.now() };
-  await fs.writeFile(notifyDaemonLockPath(), JSON.stringify(info), { mode: 0o600 });
+  const lockPath = notifyDaemonLockPath();
+  let contents = JSON.stringify({ pid: process.pid, startedAt: await processStartTimeMs(process.pid) ?? Date.now(), purpose, ready: false, owner: crypto.randomUUID() });
+  const create = async () => {
+    // Publish a fully written record atomically; a killed writer cannot leave partial JSON.
+    const tmp = `${lockPath}.${crypto.randomUUID()}.tmp`;
+    try {
+      await fs.writeFile(tmp, contents, { mode: 0o600, flag: "wx" });
+      await fs.link(tmp, lockPath);
+      return true;
+    } catch (error) {
+      if ((error as NodeJS.ErrnoException).code === "EEXIST") return false;
+      throw error;
+    } finally { await fs.unlink(tmp).catch(() => {}); }
+  };
+  if (!(await create())) {
+    // Serialize stale-owner reclamation so a second contender cannot unlink the winner.
+    let reclaim: fs.FileHandle;
+    try { reclaim = await fs.open(`${lockPath}.reclaim`, "wx", 0o600); }
+    catch (error) {
+      if ((error as NodeJS.ErrnoException).code === "EEXIST") {
+        const blocked = await interruptedRecoveryMessage();
+        if (blocked) throw new Error(blocked);
+        return undefined;
+      }
+      throw error;
+    }
+    try {
+      const existing = await readDaemonLock();
+      if (existing && await isLockOwnerAlive(existing)) return undefined;
+      // Recover legacy malformed locks only after a grace period for old writers.
+      if (!existing && Date.now() - (await fs.stat(lockPath)).mtimeMs < 30_000) return undefined;
+      await fs.unlink(lockPath);
+      if (!(await create())) return undefined;
+    } finally {
+      await reclaim.close();
+      await fs.unlink(`${lockPath}.reclaim`).catch(() => {});
+    }
+  }
   return {
+    markReady: async () => {
+      if (await fs.readFile(lockPath, "utf-8").catch(() => "") !== contents) throw new Error("Notification daemon lost lock ownership during startup");
+      const next = JSON.stringify({ ...JSON.parse(contents), ready: true });
+      const tmp = `${lockPath}.${crypto.randomUUID()}.tmp`;
+      try {
+        await fs.writeFile(tmp, next, { mode: 0o600, flag: "wx" });
+        await fs.rename(tmp, lockPath);
+        contents = next;
+      } finally { await fs.unlink(tmp).catch(() => {}); }
+    },
     release: async () => {
-      await fs.unlink(notifyDaemonLockPath()).catch(() => {});
+      // An old release closure must not remove a newer owner's lock.
+      if (await fs.readFile(lockPath, "utf-8").catch(() => "") === contents) await fs.unlink(lockPath).catch(() => {});
     },
   };
 }
 
 export interface DaemonStatus {
-  /** `notifications.enabled` + a stored bot token + chat id are all present. */
+  /** Master toggle and at least one complete, authorized transport. */
   configured: boolean;
   running: boolean;
+  pairing?: boolean;
+  ready?: boolean;
   /** A lock file exists but its pid is dead — a previous daemon crashed without cleanup. */
   stale: boolean;
   pid?: number;
@@ -190,7 +247,12 @@ export interface DaemonStatus {
 
 export async function isNotifyConfigured(): Promise<boolean> {
   const config = await readGlobalConfig();
-  return Boolean(config.notifications?.enabled && config.notifications.telegram?.botToken && config.notifications.telegram?.chatId);
+  const n = config.notifications;
+  return Boolean(n?.enabled && (
+    (n.telegram?.botToken && n.telegram.chatId) ||
+    (n.discord?.botToken && n.discord.channelId && n.discord.allowedUserIds?.length) ||
+    (n.slack?.botToken && n.slack.appToken && n.slack.channelId && n.slack.allowedUserIds?.length)
+  ));
 }
 
 export async function daemonStatus(): Promise<DaemonStatus> {
@@ -199,7 +261,7 @@ export async function daemonStatus(): Promise<DaemonStatus> {
   const { alive, verified } = await inspectLockOwner(lock);
   // Surface the degraded case instead of hiding it: on a host with no `/proc` and no
   // usable `ps`, "running" is an existence-only guess that cannot rule out PID reuse.
-  return { configured, running: alive, stale: !alive, pid: lock.pid, startedAt: lock.startedAt, ownerVerified: verified };
+  return { configured, running: alive && lock.purpose !== "pairing", pairing: alive && lock.purpose === "pairing", ready: alive && lock.ready === true, stale: !alive, pid: lock.pid, startedAt: lock.startedAt, ownerVerified: verified };
 }
 
 /** Self-invocation argv for the daemon child (mirrors `memory.ts`'s
@@ -240,10 +302,11 @@ async function waitFor(predicate: () => Promise<boolean>, timeoutMs: number, ste
   return false;
 }
 
-export async function startDaemon(spawnImpl: SpawnLike = defaultSpawn): Promise<{ ok: boolean; pid?: number; message: string }> {
+export async function startDaemon(spawnImpl: SpawnLike = defaultSpawn, waitImpl: (predicate: () => Promise<boolean>, timeoutMs: number) => Promise<boolean> = waitFor): Promise<{ ok: boolean; pid?: number; message: string }> {
   const existing = await readDaemonLock();
   if (existing && (await isLockOwnerAlive(existing))) {
-    return { ok: true, pid: existing.pid, message: `daemon already running (pid ${existing.pid})` };
+    if (existing.purpose === "pairing") return { ok: false, message: "Telegram pairing currently owns the notification lock; finish setup first." };
+    return { ok: existing.ready === true, pid: existing.pid, message: `daemon ${existing.ready !== true ? "is still initializing" : "already running"} (pid ${existing.pid}); connectivity not checked` };
   }
   // Check BEFORE spawning: an unconfigured daemon exits almost immediately (see
   // `runNotifyDaemonForeground`), which races the readiness poll below and used to
@@ -252,24 +315,45 @@ export async function startDaemon(spawnImpl: SpawnLike = defaultSpawn): Promise<
     return { ok: false, message: "notifications not configured — run 'jeo notify setup' first." };
   }
 
+  const blocked = await interruptedRecoveryMessage();
+  if (blocked) return { ok: false, message: blocked };
+
   const cmd = daemonInvocation(process.argv[1], process.execPath, process.cwd());
   spawnImpl(cmd, process.cwd()).unref();
-  const ready = await waitFor(async () => {
+  const ready = await waitImpl(async () => {
     const lock = await readDaemonLock();
-    return Boolean(lock && isPidAlive(lock.pid));
-  }, 2_000);
-  if (!ready) return { ok: false, message: `daemon did not report ready within 2s — check ${notifyDaemonLogPath()}` };
+    return Boolean(lock && lock.purpose === "daemon" && lock.ready === true && isPidAlive(lock.pid));
+  }, 15_000);
+  if (!ready) return { ok: false, message: `daemon did not initialize within 15s — check ${notifyDaemonLogPath()}` };
   const lock = await readDaemonLock();
-  return { ok: true, pid: lock?.pid, message: `daemon started (pid ${lock?.pid})` };
+  return { ok: true, pid: lock?.pid, message: `daemon initialized (pid ${lock?.pid}); use notify health to check platform access` };
+}
+
+async function removeStoppedLock(expected: DaemonLockInfo): Promise<void> {
+  const lockPath = notifyDaemonLockPath();
+  let guard: fs.FileHandle;
+  try { guard = await fs.open(`${lockPath}.reclaim`, "wx", 0o600); }
+  catch (error) {
+    if (["EEXIST", "ENOENT"].includes((error as NodeJS.ErrnoException).code ?? "")) return;
+    throw error;
+  }
+  try {
+    const current = await readDaemonLock();
+    if (current?.pid === expected.pid && current.startedAt === expected.startedAt && !(await isLockOwnerAlive(current))) await fs.unlink(lockPath).catch(() => {});
+  } finally {
+    await guard.close();
+    await fs.unlink(`${lockPath}.reclaim`).catch(() => {});
+  }
 }
 
 export async function stopDaemon(): Promise<{ ok: boolean; message: string }> {
   const lock = await readDaemonLock();
   const owner = lock ? await inspectLockOwner(lock) : undefined;
   if (!lock || !owner?.alive) {
-    await fs.unlink(notifyDaemonLockPath()).catch(() => {});
+    if (lock) await removeStoppedLock(lock);
     return { ok: true, message: "daemon was not running" };
   }
+  if (lock.purpose === "pairing") return { ok: false, message: "Telegram pairing is active; cancel setup in its terminal first." };
   try {
     process.kill(lock.pid, "SIGTERM");
   } catch (err) {
@@ -277,13 +361,14 @@ export async function stopDaemon(): Promise<{ ok: boolean; message: string }> {
   }
   const stopped = await waitFor(async () => !isPidAlive(lock.pid), 3_000);
   if (!stopped) return { ok: false, message: `daemon (pid ${lock.pid}) did not exit within 3s` };
-  await fs.unlink(notifyDaemonLockPath()).catch(() => {});
+  await removeStoppedLock(lock);
   const caveat = owner.verified ? "" : " (start time unverifiable on this host — PID reuse could not be ruled out)";
   return { ok: true, message: `daemon stopped (was pid ${lock.pid})${caveat}` };
 }
 
-export async function reloadDaemon(spawnImpl: SpawnLike = defaultSpawn): Promise<{ ok: boolean; message: string }> {
-  const stopRes = await stopDaemon();
+export async function reloadDaemon(spawnImpl: SpawnLike = defaultSpawn, stopImpl: typeof stopDaemon = stopDaemon): Promise<{ ok: boolean; message: string }> {
+  const stopRes = await stopImpl();
+  if (!stopRes.ok) return stopRes;
   const startRes = await startDaemon(spawnImpl);
   return { ok: startRes.ok, message: `${stopRes.message}; ${startRes.message}` };
 }

package/src/agent/notify/discord-api.ts

@@ -0,0 +1,148 @@
+import { version } from "../../../package.json";
+
+/** Native Discord bot REST surface. Tokens are headers only; errors never include response bodies. */
+export interface DiscordApiOptions {
+  fetchImpl?: typeof fetch;
+  now?: () => number;
+  sleep?: (ms: number, signal: AbortSignal) => Promise<void>;
+  requestTimeoutMs?: number;
+  maxRetries?: number;
+}
+
+export class DiscordApiError extends Error {
+  constructor(message: string, readonly status?: number, readonly retryAfterMs?: number, readonly sentMessages: { id: string }[] = []) {
+    super(message);
+    this.name = "DiscordApiError";
+  }
+}
+
+export interface DiscordGatewayInfo {
+  url: string;
+  session_start_limit: { remaining: number; reset_after: number; total: number; max_concurrency: number };
+}
+
+function delay(ms: number, signal: AbortSignal): Promise<void> {
+  const { promise, resolve, reject } = Promise.withResolvers<void>();
+  const abort = () => { clearTimeout(timer); reject(new DiscordApiError("Discord request stopped")); };
+  const timer = setTimeout(() => { signal.removeEventListener("abort", abort); resolve(); }, ms);
+  if (signal.aborted) abort();
+  else signal.addEventListener("abort", abort, { once: true });
+  return promise;
+}
+
+export class DiscordApi {
+  private readonly controller = new AbortController();
+  private cooldownUntil = 0;
+  private fatalStatus: number | undefined;
+  private queue = Promise.resolve();
+  private queued = 0;
+
+  constructor(private readonly token: string, private readonly options: DiscordApiOptions = {}) {}
+
+  stop(): void { this.controller.abort(); }
+
+  private request<T>(route: string, body?: unknown): Promise<T> {
+    if (this.queued >= 128) return Promise.reject(new DiscordApiError("Discord request queue full"));
+    this.queued++;
+    const result = this.queue.then(() => this.perform<T>(route, body));
+    this.queue = result.then(() => {}, () => {}).finally(() => { this.queued--; });
+    return result;
+  }
+
+  private async perform<T>(route: string, body?: unknown): Promise<T> {
+    const now = this.options.now ?? Date.now;
+    const retries = Math.max(0, Math.min(this.options.maxRetries ?? 2, 3));
+    for (let attempt = 0; attempt <= retries; attempt++) {
+      if (this.controller.signal.aborted) throw new DiscordApiError("Discord request stopped");
+      if (this.fatalStatus) throw new DiscordApiError("Discord authentication or permission denied", this.fatalStatus);
+      const wait = this.cooldownUntil - now();
+      if (wait > 30_000) throw new DiscordApiError("Discord rate limit cooldown active", 429, wait);
+      if (wait > 0) await (this.options.sleep ?? delay)(wait, this.controller.signal);
+      if (this.controller.signal.aborted) throw new DiscordApiError("Discord request stopped");
+      const timeout = AbortSignal.timeout(Math.max(1, Math.min(this.options.requestTimeoutMs ?? 10_000, 30_000)));
+      let response: Response;
+      let data: unknown;
+      try {
+        response = await (this.options.fetchImpl ?? fetch)(`https://discord.com/api/v10${route}`, {
+          method: body === undefined ? "GET" : "POST",
+          headers: { Authorization: `Bot ${this.token}`, "Content-Type": "application/json", "User-Agent": `DiscordBot (https://github.com/akillness/jeo-code, ${version})` },
+          body: body === undefined ? undefined : JSON.stringify(body),
+          signal: AbortSignal.any([this.controller.signal, timeout]),
+          redirect: "error",
+        });
+        if (response.status === 401 || response.status === 403) this.fatalStatus = response.status;
+        data = await response.json().catch(error => {
+          if (response.ok) throw error;
+          return null; // HTTP denial/cooldown headers remain authoritative without a JSON body.
+        });
+      } catch {
+        // Never retry an uncertain POST: Discord may already have accepted it.
+        if (this.fatalStatus) throw new DiscordApiError("Discord authentication or permission denied", this.fatalStatus);
+        throw new DiscordApiError("Discord request failed or timed out");
+      }
+      const record = data && typeof data === "object" ? data as Record<string, unknown> : {};
+      if (response.status === 429 || response.headers.get("X-RateLimit-Remaining") === "0") {
+        const raw = Number(response.status === 429
+          ? record.retry_after ?? response.headers.get("Retry-After")
+          : response.headers.get("X-RateLimit-Reset-After"));
+        const ms = Number.isFinite(raw) && raw > 0 ? raw * 1000 : 30_000;
+        // One serialized bot lane conservatively honors both route and global cooldowns.
+        this.cooldownUntil = Math.max(this.cooldownUntil, now() + ms);
+      }
+      if (response.status === 429 && attempt < retries) continue;
+      if (!response.ok) throw new DiscordApiError(`Discord HTTP ${response.status}`, response.status, Math.max(0, this.cooldownUntil - now()));
+      if (!data || typeof data !== "object" || Array.isArray(data)) throw new DiscordApiError("Invalid Discord response");
+      return data as T;
+    }
+    throw new DiscordApiError("Discord retry limit reached");
+  }
+
+  async getMe(): Promise<{ id: string; username: string; bot: boolean }> {
+    const me = await this.request<{ id: string; username: string; bot: boolean }>("/users/@me");
+    if (!/^\d+$/.test(me.id) || typeof me.id !== "string" || typeof me.username !== "string" || me.bot !== true) {
+      throw new DiscordApiError("Discord bot identity required");
+    }
+    return me;
+  }
+
+  async getChannel(channelId: string): Promise<{ id: string; type: number }> {
+    this.checkId(channelId);
+    const channel = await this.request<{ id: string; type: number }>(`/channels/${channelId}`);
+    if (channel.id !== channelId || !Number.isInteger(channel.type)) throw new DiscordApiError("Invalid Discord channel");
+    return channel;
+  }
+
+  async getGatewayBot(): Promise<DiscordGatewayInfo> {
+    const gateway = await this.request<DiscordGatewayInfo>("/gateway/bot");
+    const limit = gateway.session_start_limit;
+    if (typeof gateway.url !== "string" || !limit || !Number.isSafeInteger(limit.remaining) || limit.remaining < 0 ||
+        !Number.isFinite(limit.reset_after) || limit.reset_after < 0 || !Number.isSafeInteger(limit.total) || limit.total < 1 ||
+        !Number.isSafeInteger(limit.max_concurrency) || limit.max_concurrency < 1) throw new DiscordApiError("Invalid Discord gateway response");
+    return gateway;
+  }
+
+  async sendMessage(channelId: string, content: string): Promise<{ id: string }[]> {
+    this.checkId(channelId);
+    if (!content.trim()) return [];
+    if (content.length > 256_000) throw new DiscordApiError("Discord message exceeds relay limit");
+    const messages: { id: string }[] = [];
+    for (let offset = 0; offset < content.length;) {
+      let end = Math.min(offset + 2000, content.length);
+      if (end < content.length && /[\uD800-\uDBFF]/.test(content[end - 1]!)) end--;
+      const message = await this.request<{ id: string }>(`/channels/${channelId}/messages`, {
+        content: content.slice(offset, end), allowed_mentions: { parse: [], replied_user: false },
+      }).catch(error => {
+        if (error instanceof DiscordApiError) throw new DiscordApiError(error.message, error.status, error.retryAfterMs, messages);
+        throw new DiscordApiError("Discord delivery failed", undefined, undefined, messages);
+      });
+      if (typeof message.id !== "string" || !/^\d+$/.test(message.id)) throw new DiscordApiError("Invalid Discord message ID", undefined, undefined, messages);
+      messages.push(message);
+      offset = end;
+    }
+    return messages;
+  }
+
+  private checkId(id: string): void {
+    if (typeof id !== "string" || !/^\d{1,20}$/.test(id)) throw new DiscordApiError("Invalid Discord ID");
+  }
+}