@creativeintelligence/abbie 0.1.0

package/src/lib/session-state.ts

@@ -0,0 +1,470 @@
+import { Database } from "bun:sqlite";
+import { randomUUID } from "node:crypto";
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { homedir } from "node:os";
+import { join } from "node:path";
+import type { AgentType } from "./types.js";
+
+export type SessionStateStatus = "active" | "completed" | "failed" | "stopped";
+
+/**
+ * Agent type for session state tracking.
+ * Uses the full AgentType union to support all agents.
+ */
+export type SessionAgentType = AgentType;
+
+export interface SessionStateRecord {
+  session_id: string;
+  device_id: string;
+  agent: string;
+  project: string | null;
+  cwd: string | null;
+  pid: number | null;
+  started_at: string;
+  updated_at: string;
+  ended_at: string | null;
+  status: SessionStateStatus;
+  metadata: Record<string, unknown>;
+}
+
+export interface InitSessionStateOptions {
+  sessionId: string;
+  agent?: SessionAgentType;
+  project?: string;
+  cwd?: string;
+  pid?: number | null;
+  metadata?: Record<string, unknown>;
+}
+
+export interface UpdateSessionStateOptions {
+  sessionId: string;
+  set?: Record<string, unknown>;
+  merge?: Record<string, unknown>;
+}
+
+export interface EndSessionStateOptions {
+  sessionId: string;
+  status?: Exclude<SessionStateStatus, "active">;
+}
+
+export interface ListSessionStateOptions {
+  status?: SessionStateStatus;
+  project?: string;
+  agent?: SessionAgentType;
+  deviceId?: string;
+  limit?: number;
+}
+
+export interface CleanupSessionStateOptions {
+  olderThan?: string;
+  dryRun?: boolean;
+}
+
+export interface CleanupSessionStateResult {
+  device_id: string;
+  older_than: string;
+  dry_run: boolean;
+  zombies: SessionStateRecord[];
+  deleted: Array<{ session_id: string; ended_at: string | null }>;
+}
+
+function resolveHomeDir(): string {
+  return process.env.HOME || homedir();
+}
+
+function getStateDir(homeDir = resolveHomeDir()): string {
+  return join(homeDir, ".abbie", "state");
+}
+
+function ensureDir(path: string): void {
+  if (!existsSync(path)) {
+    mkdirSync(path, { recursive: true });
+  }
+}
+
+function readJsonObject(value: unknown): Record<string, unknown> {
+  if (typeof value !== "string" || value.trim().length === 0) return {};
+  try {
+    const parsed = JSON.parse(value) as unknown;
+    if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) {
+      return parsed as Record<string, unknown>;
+    }
+    return {};
+  } catch {
+    return {};
+  }
+}
+
+function parseOlderThanToSqliteModifier(input: string): string {
+  const raw = input.trim();
+  const match = raw.match(/^(\d+)\s*([smhdw])$/i);
+  if (!match) {
+    throw new Error(`Invalid --older-than value: ${input} (expected e.g. 7d, 12h, 30m)`);
+  }
+
+  const amount = Number(match[1]);
+  const unit = match[2].toLowerCase();
+  if (!Number.isFinite(amount) || amount <= 0) {
+    throw new Error(`Invalid --older-than value: ${input} (must be a positive duration)`);
+  }
+
+  switch (unit) {
+    case "s":
+      return `-${amount} seconds`;
+    case "m":
+      return `-${amount} minutes`;
+    case "h":
+      return `-${amount} hours`;
+    case "d":
+      return `-${amount} days`;
+    case "w":
+      return `-${amount * 7} days`;
+    default:
+      throw new Error(`Invalid --older-than unit: ${unit}`);
+  }
+}
+
+function isProcessRunning(pid: number): boolean {
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+export class SessionStateManager {
+  private stateDir: string;
+  private dbPath: string;
+  private deviceIdPath: string;
+
+  constructor(options?: { stateDir?: string }) {
+    const resolvedStateDir = options?.stateDir ?? getStateDir();
+    this.stateDir = resolvedStateDir;
+    this.dbPath = join(this.stateDir, "sessions.db");
+    this.deviceIdPath = join(this.stateDir, "device.id");
+
+    ensureDir(this.stateDir);
+  }
+
+  getDeviceId(): string {
+    ensureDir(this.stateDir);
+    if (existsSync(this.deviceIdPath)) {
+      const existing = readFileSync(this.deviceIdPath, "utf-8").trim();
+      if (existing.length > 0) return existing;
+    }
+
+    const id = randomUUID();
+    writeFileSync(this.deviceIdPath, `${id}\n`, { encoding: "utf-8" });
+    return id;
+  }
+
+  private openDb(): Database {
+    ensureDir(this.stateDir);
+    const db = new Database(this.dbPath);
+
+    // Concurrency-safe settings for multi-process writes.
+    db.exec("PRAGMA journal_mode = WAL;");
+    db.exec("PRAGMA synchronous = NORMAL;");
+    db.exec("PRAGMA busy_timeout = 5000;");
+
+    this.ensureSchema(db);
+    return db;
+  }
+
+  private ensureSchema(db: Database): void {
+    db.exec(`
+      CREATE TABLE IF NOT EXISTS sessions (
+        session_id TEXT PRIMARY KEY,
+        device_id TEXT NOT NULL,
+        agent TEXT NOT NULL DEFAULT 'claude',
+        project TEXT,
+        cwd TEXT,
+        pid INTEGER,
+        started_at TEXT DEFAULT (datetime('now')),
+        updated_at TEXT DEFAULT (datetime('now')),
+        ended_at TEXT,
+        status TEXT DEFAULT 'active',
+        metadata TEXT DEFAULT '{}'
+      );
+      CREATE INDEX IF NOT EXISTS idx_sessions_status ON sessions(status);
+      CREATE INDEX IF NOT EXISTS idx_sessions_project ON sessions(project);
+      CREATE INDEX IF NOT EXISTS idx_sessions_device ON sessions(device_id);
+    `);
+  }
+
+  private rowToRecord(row: Record<string, unknown>): SessionStateRecord {
+    const status = String(row.status ?? "active") as SessionStateStatus;
+
+    return {
+      session_id: String(row.session_id),
+      device_id: String(row.device_id),
+      agent: String(row.agent ?? "claude"),
+      project: row.project === null || row.project === undefined ? null : String(row.project),
+      cwd: row.cwd === null || row.cwd === undefined ? null : String(row.cwd),
+      pid: row.pid === null || row.pid === undefined ? null : Number(row.pid),
+      started_at: String(row.started_at ?? ""),
+      updated_at: String(row.updated_at ?? ""),
+      ended_at: row.ended_at === null || row.ended_at === undefined ? null : String(row.ended_at),
+      status,
+      metadata: readJsonObject(row.metadata),
+    };
+  }
+
+  get(sessionId: string): SessionStateRecord | null {
+    const db = this.openDb();
+    try {
+      const row = db.query("SELECT * FROM sessions WHERE session_id = ?").get(sessionId) as
+        | Record<string, unknown>
+        | undefined;
+      if (!row) return null;
+      return this.rowToRecord(row);
+    } finally {
+      db.close();
+    }
+  }
+
+  init(options: InitSessionStateOptions): SessionStateRecord {
+    const deviceId = this.getDeviceId();
+    const agent = options.agent ?? "claude";
+    const project = options.project ?? null;
+    const cwd = options.cwd ?? null;
+    const pid = options.pid ?? null;
+    const metadataJson = options.metadata ? JSON.stringify(options.metadata) : undefined;
+
+    const db = this.openDb();
+    try {
+      db.exec("BEGIN IMMEDIATE;");
+      try {
+        if (metadataJson !== undefined) {
+          db.query(
+            "INSERT OR IGNORE INTO sessions (session_id, device_id, agent, project, cwd, pid, metadata) VALUES (?, ?, ?, ?, ?, ?, ?)",
+          ).run(options.sessionId, deviceId, agent, project, cwd, pid, metadataJson);
+        } else {
+          db.query(
+            "INSERT OR IGNORE INTO sessions (session_id, device_id, agent, project, cwd, pid) VALUES (?, ?, ?, ?, ?, ?)",
+          ).run(options.sessionId, deviceId, agent, project, cwd, pid);
+        }
+
+        if (metadataJson !== undefined) {
+          db.query(
+            "UPDATE sessions SET device_id = ?, agent = ?, project = ?, cwd = ?, pid = ?, status = 'active', ended_at = NULL, updated_at = datetime('now'), metadata = ? WHERE session_id = ?",
+          ).run(deviceId, agent, project, cwd, pid, metadataJson, options.sessionId);
+        } else {
+          db.query(
+            "UPDATE sessions SET device_id = ?, agent = ?, project = ?, cwd = ?, pid = ?, status = 'active', ended_at = NULL, updated_at = datetime('now') WHERE session_id = ?",
+          ).run(deviceId, agent, project, cwd, pid, options.sessionId);
+        }
+
+        db.exec("COMMIT;");
+      } catch (err) {
+        db.exec("ROLLBACK;");
+        throw err;
+      }
+
+      const row = db.query("SELECT * FROM sessions WHERE session_id = ?").get(options.sessionId) as
+        | Record<string, unknown>
+        | undefined;
+      if (!row) {
+        throw new Error(`Failed to init session state for ${options.sessionId}`);
+      }
+      return this.rowToRecord(row);
+    } finally {
+      db.close();
+    }
+  }
+
+  update(options: UpdateSessionStateOptions): SessionStateRecord | null {
+    const db = this.openDb();
+    try {
+      db.exec("BEGIN IMMEDIATE;");
+      try {
+        const row = db
+          .query("SELECT * FROM sessions WHERE session_id = ?")
+          .get(options.sessionId) as Record<string, unknown> | undefined;
+        if (!row) {
+          db.exec("ROLLBACK;");
+          return null;
+        }
+
+        const record = this.rowToRecord(row);
+        const nextMetadata: Record<string, unknown> = { ...record.metadata };
+
+        if (options.merge) {
+          for (const [k, v] of Object.entries(options.merge)) {
+            nextMetadata[k] = v;
+          }
+        }
+        if (options.set) {
+          for (const [k, v] of Object.entries(options.set)) {
+            nextMetadata[k] = v;
+          }
+        }
+
+        const json = JSON.stringify(nextMetadata);
+        db.query(
+          "UPDATE sessions SET metadata = ?, updated_at = datetime('now') WHERE session_id = ?",
+        ).run(json, options.sessionId);
+        db.exec("COMMIT;");
+      } catch (err) {
+        db.exec("ROLLBACK;");
+        throw err;
+      }
+
+      const updated = db
+        .query("SELECT * FROM sessions WHERE session_id = ?")
+        .get(options.sessionId) as Record<string, unknown> | undefined;
+      return updated ? this.rowToRecord(updated) : null;
+    } finally {
+      db.close();
+    }
+  }
+
+  end(options: EndSessionStateOptions): SessionStateRecord | null {
+    const status = options.status ?? "completed";
+    const db = this.openDb();
+    try {
+      db.exec("BEGIN IMMEDIATE;");
+      try {
+        const existing = db
+          .query("SELECT session_id FROM sessions WHERE session_id = ?")
+          .get(options.sessionId) as Record<string, unknown> | undefined;
+        if (!existing) {
+          db.exec("ROLLBACK;");
+          return null;
+        }
+
+        db.query(
+          "UPDATE sessions SET status = ?, ended_at = COALESCE(ended_at, datetime('now')), updated_at = datetime('now') WHERE session_id = ?",
+        ).run(status, options.sessionId);
+        db.exec("COMMIT;");
+      } catch (err) {
+        db.exec("ROLLBACK;");
+        throw err;
+      }
+
+      const row = db.query("SELECT * FROM sessions WHERE session_id = ?").get(options.sessionId) as
+        | Record<string, unknown>
+        | undefined;
+      return row ? this.rowToRecord(row) : null;
+    } finally {
+      db.close();
+    }
+  }
+
+  list(options?: ListSessionStateOptions): SessionStateRecord[] {
+    const db = this.openDb();
+    try {
+      let sql = "SELECT * FROM sessions WHERE 1=1";
+      const params: Array<string | number> = [];
+
+      if (options?.status) {
+        sql += " AND status = ?";
+        params.push(options.status);
+      }
+      if (options?.project) {
+        sql += " AND project = ?";
+        params.push(options.project);
+      }
+      if (options?.agent) {
+        sql += " AND agent = ?";
+        params.push(options.agent);
+      }
+      if (options?.deviceId) {
+        sql += " AND device_id = ?";
+        params.push(options.deviceId);
+      }
+
+      sql += " ORDER BY started_at DESC";
+
+      if (options?.limit && options.limit > 0) {
+        sql += " LIMIT ?";
+        params.push(options.limit);
+      }
+
+      const rows = db.query(sql).all(...params) as Array<Record<string, unknown>>;
+      return rows.map((r) => this.rowToRecord(r));
+    } finally {
+      db.close();
+    }
+  }
+
+  cleanup(options?: CleanupSessionStateOptions): CleanupSessionStateResult {
+    const olderThan = options?.olderThan ?? "7d";
+    const dryRun = options?.dryRun ?? false;
+    const deviceId = this.getDeviceId();
+    const olderThanModifier = parseOlderThanToSqliteModifier(olderThan);
+
+    const db = this.openDb();
+    try {
+      // Zombie detection: only safe on current device because PIDs are not globally unique.
+      const candidates = db
+        .query(
+          "SELECT * FROM sessions WHERE status = 'active' AND device_id = ? AND pid IS NOT NULL AND ended_at IS NULL",
+        )
+        .all(deviceId) as Array<Record<string, unknown>>;
+
+      const zombieIds: string[] = [];
+      for (const row of candidates) {
+        const pid = row.pid === null || row.pid === undefined ? null : Number(row.pid);
+        if (!pid) continue;
+        if (!isProcessRunning(pid)) {
+          zombieIds.push(String(row.session_id));
+        }
+      }
+
+      const zombies: SessionStateRecord[] = [];
+      if (zombieIds.length > 0) {
+        if (!dryRun) {
+          db.exec("BEGIN IMMEDIATE;");
+          try {
+            for (const id of zombieIds) {
+              db.query(
+                "UPDATE sessions SET status = 'stopped', ended_at = COALESCE(ended_at, datetime('now')), updated_at = datetime('now') WHERE session_id = ?",
+              ).run(id);
+            }
+            db.exec("COMMIT;");
+          } catch (err) {
+            db.exec("ROLLBACK;");
+            throw err;
+          }
+        }
+
+        for (const id of zombieIds) {
+          const row = db.query("SELECT * FROM sessions WHERE session_id = ?").get(id) as
+            | Record<string, unknown>
+            | undefined;
+          if (row) zombies.push(this.rowToRecord(row));
+        }
+      }
+
+      // Delete old ended sessions.
+      const oldRows = db
+        .query(
+          "SELECT session_id, ended_at FROM sessions WHERE ended_at IS NOT NULL AND ended_at < datetime('now', ?)",
+        )
+        .all(olderThanModifier) as Array<Record<string, unknown>>;
+
+      const deleted: Array<{ session_id: string; ended_at: string | null }> = oldRows.map((r) => ({
+        session_id: String(r.session_id),
+        ended_at: r.ended_at === null || r.ended_at === undefined ? null : String(r.ended_at),
+      }));
+
+      if (!dryRun && deleted.length > 0) {
+        db.query(
+          "DELETE FROM sessions WHERE ended_at IS NOT NULL AND ended_at < datetime('now', ?)",
+        ).run(olderThanModifier);
+      }
+
+      return {
+        device_id: deviceId,
+        older_than: olderThan,
+        dry_run: dryRun,
+        zombies,
+        deleted,
+      };
+    } finally {
+      db.close();
+    }
+  }
+}

package/src/lib/slack-workspace.ts

@@ -0,0 +1,25 @@
+/**
+ * Central Slack workspace resolver for abbie CLI.
+ *
+ * Decouples runtime Slack routing from project/app names.
+ */
+
+const FALLBACK_SLACK_WORKSPACE = "creative-int-co";
+
+function normalizeWorkspace(value?: string): string | undefined {
+  const trimmed = value?.trim();
+  return trimmed ? trimmed : undefined;
+}
+
+export function getDefaultSlackWorkspace(): string {
+  return normalizeWorkspace(process.env.ABBIE_SLACK_WORKSPACE) ?? FALLBACK_SLACK_WORKSPACE;
+}
+
+export function toSlackTokenEnvVar(workspace = getDefaultSlackWorkspace()): string {
+  const suffix = workspace
+    .toUpperCase()
+    .replace(/[^A-Z0-9]+/g, "_")
+    .replace(/^_+|_+$/g, "");
+
+  return `SLACK_BOT_TOKEN_${suffix}`;
+}