@vellumai/assistant 0.3.5 → 0.3.7

package/src/daemon/daemon-control.ts

@@ -0,0 +1,254 @@
+import { spawn } from 'node:child_process';
+import { mkdirSync, readFileSync, writeFileSync, unlinkSync, existsSync, openSync, closeSync } from 'node:fs';
+import { join, resolve } from 'node:path';
+import {
+  getSocketPath,
+  getPidPath,
+  getRootDir,
+  getWorkspaceConfigPath,
+  removeSocketFile,
+} from '../util/platform.js';
+import { getLogger } from '../util/logger.js';
+import { DaemonError } from '../util/errors.js';
+
+const log = getLogger('lifecycle');
+
+const DAEMON_TIMEOUT_DEFAULTS = {
+  startupSocketWaitMs: 5000,
+  stopTimeoutMs: 5000,
+  sigkillGracePeriodMs: 2000,
+};
+
+/**
+ * Read daemon timeout values directly from the config JSON file, bypassing
+ * loadConfig() and its ensureMigratedDataDir()/ensureDataDir() side effects.
+ * Falls back to hardcoded defaults on any error (missing file, malformed JSON,
+ * unexpected shape) so daemon stop/start never fails due to config issues.
+ */
+function readDaemonTimeouts(): typeof DAEMON_TIMEOUT_DEFAULTS {
+  try {
+    const raw = JSON.parse(readFileSync(getWorkspaceConfigPath(), 'utf-8'));
+    if (raw.daemon && typeof raw.daemon === 'object') {
+      return {
+        startupSocketWaitMs:
+          typeof raw.daemon.startupSocketWaitMs === 'number'
+            ? raw.daemon.startupSocketWaitMs
+            : DAEMON_TIMEOUT_DEFAULTS.startupSocketWaitMs,
+        stopTimeoutMs:
+          typeof raw.daemon.stopTimeoutMs === 'number'
+            ? raw.daemon.stopTimeoutMs
+            : DAEMON_TIMEOUT_DEFAULTS.stopTimeoutMs,
+        sigkillGracePeriodMs:
+          typeof raw.daemon.sigkillGracePeriodMs === 'number'
+            ? raw.daemon.sigkillGracePeriodMs
+            : DAEMON_TIMEOUT_DEFAULTS.sigkillGracePeriodMs,
+      };
+    }
+  } catch {
+    // Missing file, malformed JSON, etc. — use defaults.
+  }
+  return { ...DAEMON_TIMEOUT_DEFAULTS };
+}
+
+function isProcessRunning(pid: number): boolean {
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+function readPid(): number | null {
+  const pidPath = getPidPath();
+  if (!existsSync(pidPath)) return null;
+  try {
+    const pid = parseInt(readFileSync(pidPath, 'utf-8').trim(), 10);
+    return isNaN(pid) ? null : pid;
+  } catch {
+    return null;
+  }
+}
+
+export function writePid(pid: number): void {
+  writeFileSync(getPidPath(), String(pid));
+}
+
+export function cleanupPidFile(): void {
+  const pidPath = getPidPath();
+  if (existsSync(pidPath)) {
+    unlinkSync(pidPath);
+  }
+}
+
+export function isDaemonRunning(): boolean {
+  const pid = readPid();
+  if (pid == null) return false;
+  if (!isProcessRunning(pid)) {
+    cleanupPidFile();
+    return false;
+  }
+  return true;
+}
+
+export function getDaemonStatus(): { running: boolean; pid?: number } {
+  const pid = readPid();
+  if (pid == null) return { running: false };
+  if (!isProcessRunning(pid)) {
+    cleanupPidFile();
+    return { running: false };
+  }
+  return { running: true, pid };
+}
+
+export async function startDaemon(): Promise<{
+  pid: number;
+  alreadyRunning: boolean;
+}> {
+  const status = getDaemonStatus();
+  if (status.running && status.pid) {
+    return { pid: status.pid, alreadyRunning: true };
+  }
+
+  // Only create the root dir for socket/PID — the daemon process itself
+  // handles migration + full ensureDataDir() in runDaemon(). Calling
+  // ensureDataDir() here would pre-create workspace destination dirs
+  // and cause migration moves to no-op.
+  const rootDir = getRootDir();
+  if (!existsSync(rootDir)) {
+    mkdirSync(rootDir, { recursive: true });
+  }
+
+  // Clean up stale socket (only if it's actually a Unix socket)
+  const socketPath = getSocketPath();
+  removeSocketFile(socketPath);
+
+  // Spawn the daemon as a detached child process
+  const mainPath = resolve(
+    import.meta.dirname ?? __dirname,
+    'main.ts',
+  );
+
+  // Redirect the child's stderr to a file instead of piping it back to the
+  // parent. A pipe's read end is destroyed when the parent exits, leaving
+  // fd 2 broken in the child. Bun (unlike Node.js) does not ignore SIGPIPE,
+  // so any later stderr write would silently kill the daemon.
+  const stderrPath = join(rootDir, 'daemon-stderr.log');
+  const stderrFd = openSync(stderrPath, 'w');
+
+  const child = spawn('bun', ['run', mainPath], {
+    detached: true,
+    stdio: ['ignore', 'ignore', stderrFd],
+    env: { ...process.env },
+  });
+
+  // The child inherited the fd; close the parent's copy.
+  closeSync(stderrFd);
+
+  let childExited = false;
+  let childExitCode: number | null = null;
+  child.on('exit', (code) => {
+    childExited = true;
+    childExitCode = code;
+  });
+
+  child.unref();
+
+  const pid = child.pid;
+  if (!pid) {
+    throw new DaemonError('Failed to start daemon: no PID returned');
+  }
+
+  writePid(pid);
+
+  // Wait for socket to appear
+  const timeouts = readDaemonTimeouts();
+  const maxWait = timeouts.startupSocketWaitMs;
+  const interval = 100;
+  let waited = 0;
+  while (waited < maxWait) {
+    if (existsSync(socketPath)) {
+      return { pid, alreadyRunning: false };
+    }
+    if (childExited) {
+      cleanupPidFile();
+      const stderr = readFileSync(stderrPath, 'utf-8').trim();
+      const detail = stderr
+        ? `\n${stderr}`
+        : `\nCheck logs at ~/.vellum/workspace/data/logs/ for details.`;
+      throw new DaemonError(
+        `Daemon exited immediately (code ${childExitCode ?? 'unknown'}).${detail}`,
+      );
+    }
+    await new Promise((r) => setTimeout(r, interval));
+    waited += interval;
+  }
+
+  throw new DaemonError(
+    `Daemon started but socket not available after ${maxWait}ms`,
+  );
+}
+
+export type StopResult =
+  | { stopped: true }
+  | { stopped: false; reason: 'not_running' | 'stop_failed' };
+
+export async function stopDaemon(): Promise<StopResult> {
+  const pid = readPid();
+  if (pid == null || !isProcessRunning(pid)) {
+    cleanupPidFile();
+    return { stopped: false, reason: 'not_running' };
+  }
+
+  process.kill(pid, 'SIGTERM');
+
+  const timeouts = readDaemonTimeouts();
+
+  // Wait for process to exit
+  const maxWait = timeouts.stopTimeoutMs;
+  const interval = 100;
+  let waited = 0;
+  while (waited < maxWait) {
+    if (!isProcessRunning(pid)) {
+      cleanupPidFile();
+      return { stopped: true };
+    }
+    await new Promise((r) => setTimeout(r, interval));
+    waited += interval;
+  }
+
+  // Force kill
+  try {
+    process.kill(pid, 'SIGKILL');
+  } catch (err) {
+    log.debug({ err, pid }, 'SIGKILL failed, process already exited');
+  }
+
+  // Wait for the process to actually die after SIGKILL. Without this,
+  // startDaemon() can race with the dying process's shutdown handler,
+  // which removes the socket file and bricks the new daemon.
+  const killMaxWait = timeouts.sigkillGracePeriodMs;
+  let killWaited = 0;
+  while (killWaited < killMaxWait && isProcessRunning(pid)) {
+    await new Promise((r) => setTimeout(r, 100));
+    killWaited += 100;
+  }
+
+  // Only clean up if the process has actually exited.
+  // If it's still alive after SIGKILL + timeout, preserve both socket
+  // and PID file so isDaemonRunning() still reports true and prevents
+  // a duplicate daemon from being spawned.
+  if (!isProcessRunning(pid)) {
+    removeSocketFile(getSocketPath());
+    cleanupPidFile();
+    return { stopped: true };
+  }
+
+  log.warn({ pid }, 'Daemon process still running after SIGKILL + timeout, leaving socket and PID file intact');
+  return { stopped: false, reason: 'stop_failed' };
+}
+
+export async function ensureDaemonRunning(): Promise<void> {
+  if (isDaemonRunning()) return;
+  await startDaemon();
+}

package/src/daemon/handlers/apps.ts

@@ -3,6 +3,7 @@ import { v4 as uuid } from 'uuid';
 import { existsSync, rmSync, readdirSync, readFileSync } from 'node:fs';
 import { homedir } from 'node:os';
 import { join } from 'node:path';
+import { getRuntimeHttpPort } from '../../config/env.js';
 import { queryAppRecords, createAppRecord, updateAppRecord, deleteAppRecord, listApps, getApp, getAppPreview, createApp, updateApp } from '../../memory/app-store.js';
 import { computeContentId } from '../../util/content-id.js';
 import { packageApp } from '../../bundler/app-bundler.js';
@@ -365,9 +366,7 @@ export async function handleShareAppCloud(
     const bundleData = readFileSync(result.bundlePath);
     const { shareToken } = createSharedAppLink(bundleData, result.manifest);
 
-    const port = process.env.RUNTIME_HTTP_PORT
-      ? parseInt(process.env.RUNTIME_HTTP_PORT, 10)
-      : 7821;
+    const port = getRuntimeHttpPort() ?? 7821;
     const shareUrl = `http://localhost:${port}/v1/apps/shared/${shareToken}`;
 
     ctx.send(socket, {

package/src/daemon/handlers/config-channels.ts

@@ -0,0 +1,158 @@
+import * as net from 'node:net';
+import { createVerificationChallenge, getGuardianBinding, getPendingChallenge, revokeBinding as revokeGuardianBinding, revokePendingChallenges } from '../../runtime/channel-guardian-service.js';
+import { createReadinessService, type ChannelReadinessService } from '../../runtime/channel-readiness-service.js';
+import * as externalConversationStore from '../../memory/external-conversation-store.js';
+import type {
+  GuardianVerificationRequest,
+  ChannelReadinessRequest,
+} from '../ipc-protocol.js';
+import { normalizeAssistantId } from '../../util/platform.js';
+import { log, defineHandlers, type HandlerContext } from './shared.js';
+
+// Lazy singleton — created on first use so module-load stays lightweight.
+let _readinessService: ChannelReadinessService | undefined;
+export function getReadinessService(): ChannelReadinessService {
+  if (!_readinessService) {
+    _readinessService = createReadinessService();
+  }
+  return _readinessService;
+}
+
+export function handleGuardianVerification(
+  msg: GuardianVerificationRequest,
+  socket: net.Socket,
+  ctx: HandlerContext,
+): void {
+  // Normalize the assistant ID so challenges are always stored under the
+  // same key the inbound-call path will use for lookups (typically "self").
+  const assistantId = normalizeAssistantId(msg.assistantId ?? 'self');
+  const channel = msg.channel ?? 'telegram';
+
+  try {
+    if (msg.action === 'create_challenge') {
+      const result = createVerificationChallenge(assistantId, channel, msg.sessionId);
+
+      ctx.send(socket, {
+        type: 'guardian_verification_response',
+        success: true,
+        secret: result.secret,
+        instruction: result.instruction,
+        channel,
+      });
+    } else if (msg.action === 'status') {
+      const binding = getGuardianBinding(assistantId, channel);
+      let guardianUsername: string | undefined;
+      let guardianDisplayName: string | undefined;
+      if (binding?.metadataJson) {
+        try {
+          const parsed = JSON.parse(binding.metadataJson) as Record<string, unknown>;
+          if (typeof parsed.username === 'string' && parsed.username.trim().length > 0) {
+            guardianUsername = parsed.username.trim();
+          }
+          if (typeof parsed.displayName === 'string' && parsed.displayName.trim().length > 0) {
+            guardianDisplayName = parsed.displayName.trim();
+          }
+        } catch {
+          // ignore malformed metadata
+        }
+      }
+      if (binding?.guardianDeliveryChatId && (!guardianUsername || !guardianDisplayName)) {
+        const ext = externalConversationStore.getBindingByChannelChat(
+          channel,
+          binding.guardianDeliveryChatId,
+        );
+        if (!guardianUsername && ext?.username) {
+          guardianUsername = ext.username;
+        }
+        if (!guardianDisplayName && ext?.displayName) {
+          guardianDisplayName = ext.displayName;
+        }
+      }
+      const hasPendingChallenge = getPendingChallenge(assistantId, channel) != null;
+      ctx.send(socket, {
+        type: 'guardian_verification_response',
+        success: true,
+        bound: binding != null,
+        guardianExternalUserId: binding?.guardianExternalUserId,
+        guardianUsername,
+        guardianDisplayName,
+        channel,
+        assistantId,
+        guardianDeliveryChatId: binding?.guardianDeliveryChatId,
+        hasPendingChallenge,
+      });
+    } else if (msg.action === 'revoke') {
+      revokeGuardianBinding(assistantId, channel);
+      revokePendingChallenges(assistantId, channel);
+      ctx.send(socket, {
+        type: 'guardian_verification_response',
+        success: true,
+        bound: false,
+        channel,
+      });
+    } else {
+      ctx.send(socket, {
+        type: 'guardian_verification_response',
+        success: false,
+        error: `Unknown action: ${String(msg.action)}`,
+        channel,
+      });
+    }
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    log.error({ err }, 'Failed to handle guardian verification');
+    ctx.send(socket, {
+      type: 'guardian_verification_response',
+      success: false,
+      error: message,
+      channel,
+    });
+  }
+}
+
+export async function handleChannelReadiness(
+  msg: ChannelReadinessRequest,
+  socket: net.Socket,
+  ctx: HandlerContext,
+): Promise<void> {
+  try {
+    const service = getReadinessService();
+
+    if (msg.action === 'refresh') {
+      if (msg.channel) {
+        service.invalidateChannel(msg.channel, msg.assistantId);
+      } else {
+        service.invalidateAll();
+      }
+    }
+
+    const snapshots = await service.getReadiness(msg.channel, msg.includeRemote, msg.assistantId);
+
+    ctx.send(socket, {
+      type: 'channel_readiness_response',
+      success: true,
+      snapshots: snapshots.map((s) => ({
+        channel: s.channel,
+        ready: s.ready,
+        checkedAt: s.checkedAt,
+        stale: s.stale,
+        reasons: s.reasons,
+        localChecks: s.localChecks,
+        remoteChecks: s.remoteChecks,
+      })),
+    });
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    log.error({ err }, 'Failed to handle channel readiness');
+    ctx.send(socket, {
+      type: 'channel_readiness_response',
+      success: false,
+      error: message,
+    });
+  }
+}
+
+export const channelHandlers = defineHandlers({
+  channel_readiness: handleChannelReadiness,
+  guardian_verification: handleGuardianVerification,
+});