@sna-sdk/core 0.0.0

package/dist/server/routes/agent.js

@@ -0,0 +1,148 @@
+import { Hono } from "hono";
+import { streamSSE } from "hono/streaming";
+import {
+  getProvider
+} from "../../core/providers/index.js";
+import { logger } from "../../lib/logger.js";
+function getSessionId(c) {
+  return c.req.query("session") ?? "default";
+}
+function createAgentRoutes(sessionManager) {
+  const app = new Hono();
+  app.post("/sessions", async (c) => {
+    const body = await c.req.json().catch(() => ({}));
+    try {
+      const session = sessionManager.createSession({
+        label: body.label,
+        cwd: body.cwd
+      });
+      logger.log("route", `POST /sessions \u2192 created "${session.id}"`);
+      return c.json({ status: "created", sessionId: session.id, label: session.label });
+    } catch (e) {
+      logger.err("err", `POST /sessions \u2192 ${e.message}`);
+      return c.json({ status: "error", message: e.message }, 409);
+    }
+  });
+  app.get("/sessions", (c) => {
+    return c.json({ sessions: sessionManager.listSessions() });
+  });
+  app.delete("/sessions/:id", (c) => {
+    const id = c.req.param("id");
+    if (id === "default") {
+      return c.json({ status: "error", message: "Cannot remove default session" }, 400);
+    }
+    const removed = sessionManager.removeSession(id);
+    if (!removed) {
+      return c.json({ status: "error", message: "Session not found" }, 404);
+    }
+    logger.log("route", `DELETE /sessions/${id} \u2192 removed`);
+    return c.json({ status: "removed" });
+  });
+  app.post("/start", async (c) => {
+    const sessionId = getSessionId(c);
+    const body = await c.req.json().catch(() => ({}));
+    const session = sessionManager.getOrCreateSession(sessionId);
+    if (session.process?.alive && !body.force) {
+      logger.log("route", `POST /start?session=${sessionId} \u2192 already_running`);
+      return c.json({
+        status: "already_running",
+        provider: "claude-code",
+        sessionId: session.process.sessionId
+      });
+    }
+    if (session.process?.alive) {
+      session.process.kill();
+    }
+    session.eventBuffer.length = 0;
+    const provider = getProvider(body.provider ?? "claude-code");
+    try {
+      const proc = provider.spawn({
+        cwd: session.cwd,
+        prompt: body.prompt,
+        model: body.model ?? "claude-sonnet-4-6",
+        permissionMode: body.permissionMode ?? "acceptEdits"
+      });
+      sessionManager.setProcess(sessionId, proc);
+      logger.log("route", `POST /start?session=${sessionId} \u2192 started`);
+      return c.json({
+        status: "started",
+        provider: provider.name,
+        sessionId: session.id
+      });
+    } catch (e) {
+      logger.err("err", `POST /start?session=${sessionId} failed: ${e.message}`);
+      return c.json({ status: "error", message: e.message }, 500);
+    }
+  });
+  app.post("/send", async (c) => {
+    const sessionId = getSessionId(c);
+    const session = sessionManager.getSession(sessionId);
+    if (!session?.process?.alive) {
+      logger.err("err", `POST /send?session=${sessionId} \u2192 no active session`);
+      return c.json(
+        { status: "error", message: `No active agent session "${sessionId}". Call POST /start first.` },
+        400
+      );
+    }
+    const body = await c.req.json().catch(() => ({}));
+    if (!body.message) {
+      logger.err("err", `POST /send?session=${sessionId} \u2192 empty message`);
+      return c.json({ status: "error", message: "message is required" }, 400);
+    }
+    sessionManager.touch(sessionId);
+    logger.log("route", `POST /send?session=${sessionId} \u2192 "${body.message.slice(0, 80)}"`);
+    session.process.send(body.message);
+    return c.json({ status: "sent" });
+  });
+  app.get("/events", (c) => {
+    const sessionId = getSessionId(c);
+    const session = sessionManager.getOrCreateSession(sessionId);
+    const sinceParam = c.req.query("since");
+    let cursor = sinceParam ? parseInt(sinceParam, 10) : session.eventCounter;
+    return streamSSE(c, async (stream) => {
+      const POLL_MS = 300;
+      const KEEPALIVE_MS = 15e3;
+      let lastSend = Date.now();
+      while (true) {
+        if (cursor < session.eventCounter) {
+          const startIdx = Math.max(
+            0,
+            session.eventBuffer.length - (session.eventCounter - cursor)
+          );
+          const newEvents = session.eventBuffer.slice(startIdx);
+          for (const event of newEvents) {
+            cursor++;
+            await stream.writeSSE({
+              id: String(cursor),
+              data: JSON.stringify(event)
+            });
+            lastSend = Date.now();
+          }
+        }
+        if (Date.now() - lastSend > KEEPALIVE_MS) {
+          await stream.writeSSE({ data: "" });
+          lastSend = Date.now();
+        }
+        await new Promise((r) => setTimeout(r, POLL_MS));
+      }
+    });
+  });
+  app.post("/kill", async (c) => {
+    const sessionId = getSessionId(c);
+    const killed = sessionManager.killSession(sessionId);
+    return c.json({ status: killed ? "killed" : "no_session" });
+  });
+  app.get("/status", (c) => {
+    const sessionId = getSessionId(c);
+    const session = sessionManager.getSession(sessionId);
+    return c.json({
+      alive: session?.process?.alive ?? false,
+      sessionId: session?.process?.sessionId ?? null,
+      eventCount: session?.eventCounter ?? 0
+    });
+  });
+  return app;
+}
+export {
+  createAgentRoutes
+};

package/dist/server/routes/emit.d.ts

@@ -0,0 +1,11 @@
+import * as hono_utils_http_status from 'hono/utils/http-status';
+import * as hono from 'hono';
+import { Context } from 'hono';
+
+declare function emitRoute(c: Context): Promise<(Response & hono.TypedResponse<{
+    error: string;
+}, 400, "json">) | (Response & hono.TypedResponse<{
+    id: number;
+}, hono_utils_http_status.ContentfulStatusCode, "json">)>;
+
+export { emitRoute };

package/dist/server/routes/emit.js

@@ -0,0 +1,15 @@
+import { getDb } from "../../db/schema.js";
+async function emitRoute(c) {
+  const { skill, type, message, data } = await c.req.json();
+  if (!skill || !type || !message) {
+    return c.json({ error: "missing fields" }, 400);
+  }
+  const db = getDb();
+  const result = db.prepare(
+    `INSERT INTO skill_events (skill, type, message, data) VALUES (?, ?, ?, ?)`
+  ).run(skill, type, message, data ?? null);
+  return c.json({ id: result.lastInsertRowid });
+}
+export {
+  emitRoute
+};

package/dist/server/routes/events.d.ts

@@ -0,0 +1,12 @@
+import { Context } from 'hono';
+
+/**
+ * GET /events?since=<id>
+ *
+ * SSE stream of skill_events from SQLite.
+ * Polls every 500ms for new rows with id > lastSeen.
+ */
+
+declare function eventsRoute(c: Context): Response;
+
+export { eventsRoute };

package/dist/server/routes/events.js

@@ -0,0 +1,54 @@
+import { streamSSE } from "hono/streaming";
+import { getDb } from "../../db/schema.js";
+const POLL_INTERVAL_MS = 500;
+const KEEPALIVE_INTERVAL_MS = 15e3;
+function eventsRoute(c) {
+  const sinceParam = c.req.query("since");
+  let lastId = sinceParam ? parseInt(sinceParam) : -1;
+  if (lastId === -1) {
+    const db = getDb();
+    const row = db.prepare("SELECT MAX(id) as maxId FROM skill_events").get();
+    lastId = row.maxId ?? 0;
+  }
+  return streamSSE(c, async (stream) => {
+    let closed = false;
+    stream.onAbort(() => {
+      closed = true;
+    });
+    const keepaliveTimer = setInterval(async () => {
+      if (closed) {
+        clearInterval(keepaliveTimer);
+        return;
+      }
+      try {
+        await stream.writeSSE({ data: "", event: "keepalive" });
+      } catch {
+        closed = true;
+        clearInterval(keepaliveTimer);
+      }
+    }, KEEPALIVE_INTERVAL_MS);
+    while (!closed) {
+      try {
+        const db = getDb();
+        const rows = db.prepare(`
+          SELECT id, skill, type, message, data, created_at
+          FROM skill_events
+          WHERE id > ?
+          ORDER BY id ASC
+          LIMIT 50
+        `).all(lastId);
+        for (const row of rows) {
+          if (closed) break;
+          await stream.writeSSE({ data: JSON.stringify(row) });
+          lastId = row.id;
+        }
+      } catch {
+      }
+      await stream.sleep(POLL_INTERVAL_MS);
+    }
+    clearInterval(keepaliveTimer);
+  });
+}
+export {
+  eventsRoute
+};

package/dist/server/routes/run.d.ts

@@ -0,0 +1,19 @@
+import { Context } from 'hono';
+
+/**
+ * GET /run?skill=<name>
+ *
+ * Spawn a registered command and stream stdout/stderr as SSE.
+ *
+ * @example
+ * import { createRunRoute } from "sna/server/routes/run";
+ *
+ * const runRoute = createRunRoute({
+ *   status: [TSX, "src/scripts/sna.ts", "status"],
+ *   collect: [TSX, "src/scripts/devlog.ts", "collect"],
+ * });
+ */
+
+declare function createRunRoute(commands: Record<string, string[]>): (c: Context) => Response;
+
+export { createRunRoute };

package/dist/server/routes/run.js

@@ -0,0 +1,51 @@
+import { spawn } from "child_process";
+import { streamSSE } from "hono/streaming";
+const ROOT = process.cwd();
+function createRunRoute(commands) {
+  return function runRoute(c) {
+    const skill = c.req.query("skill") ?? "";
+    const cmd = commands[skill];
+    if (!cmd) {
+      return c.text(`data: unknown skill: ${skill}
+
+data: [done]
+
+`, 200, {
+        "Content-Type": "text/event-stream"
+      });
+    }
+    return streamSSE(c, async (stream) => {
+      await stream.writeSSE({ data: `$ ${cmd.slice(1).join(" ")}` });
+      const child = spawn(cmd[0], cmd.slice(1), {
+        cwd: ROOT,
+        env: { ...process.env, FORCE_COLOR: "0" }
+      });
+      const write = (chunk) => {
+        for (const line of chunk.toString().split("\n")) {
+          if (line.trim()) stream.writeSSE({ data: line });
+        }
+      };
+      child.stdout.on("data", write);
+      child.stderr.on("data", (chunk) => {
+        for (const line of chunk.toString().split("\n")) {
+          if (line.trim() && !line.startsWith(">")) stream.writeSSE({ data: line });
+        }
+      });
+      await new Promise((resolve) => {
+        child.on("close", async (code) => {
+          await stream.writeSSE({ data: `[exit ${code ?? 0}]` });
+          await stream.writeSSE({ data: "[done]" });
+          resolve();
+        });
+        child.on("error", async (err) => {
+          await stream.writeSSE({ data: `Error: ${err.message}` });
+          await stream.writeSSE({ data: "[done]" });
+          resolve();
+        });
+      });
+    });
+  };
+}
+export {
+  createRunRoute
+};

package/dist/server/session-manager.d.ts

@@ -0,0 +1,64 @@
+import { AgentProcess, AgentEvent } from '../core/providers/types.js';
+
+/**
+ * SessionManager — manages multiple independent agent sessions.
+ *
+ * Each session owns its own AgentProcess, event buffer, and cursor.
+ * The default "default" session provides backward compatibility.
+ */
+
+interface Session {
+    id: string;
+    process: AgentProcess | null;
+    eventBuffer: AgentEvent[];
+    eventCounter: number;
+    label: string;
+    cwd: string;
+    createdAt: number;
+    lastActivityAt: number;
+}
+interface SessionInfo {
+    id: string;
+    label: string;
+    alive: boolean;
+    cwd: string;
+    eventCount: number;
+    createdAt: number;
+    lastActivityAt: number;
+}
+interface SessionManagerOptions {
+    maxSessions?: number;
+}
+declare class SessionManager {
+    private sessions;
+    private maxSessions;
+    constructor(options?: SessionManagerOptions);
+    /** Create a new session. Throws if max sessions reached. */
+    createSession(opts?: {
+        id?: string;
+        label?: string;
+        cwd?: string;
+    }): Session;
+    /** Get a session by ID. */
+    getSession(id: string): Session | undefined;
+    /** Get or create a session (used for "default" backward compat). */
+    getOrCreateSession(id: string, opts?: {
+        label?: string;
+        cwd?: string;
+    }): Session;
+    /** Set the agent process for a session. Subscribes to events. */
+    setProcess(sessionId: string, proc: AgentProcess): void;
+    /** Kill the agent process in a session (session stays, can be restarted). */
+    killSession(id: string): boolean;
+    /** Remove a session entirely. Cannot remove "default". */
+    removeSession(id: string): boolean;
+    /** List all sessions as serializable info objects. */
+    listSessions(): SessionInfo[];
+    /** Touch a session's lastActivityAt timestamp. */
+    touch(id: string): void;
+    /** Kill all sessions. Used during shutdown. */
+    killAll(): void;
+    get size(): number;
+}
+
+export { type Session, type SessionInfo, SessionManager, type SessionManagerOptions };

package/dist/server/session-manager.js

@@ -0,0 +1,101 @@
+const DEFAULT_MAX_SESSIONS = 5;
+const MAX_EVENT_BUFFER = 500;
+class SessionManager {
+  constructor(options = {}) {
+    this.sessions = /* @__PURE__ */ new Map();
+    this.maxSessions = options.maxSessions ?? DEFAULT_MAX_SESSIONS;
+  }
+  /** Create a new session. Throws if max sessions reached. */
+  createSession(opts = {}) {
+    const id = opts.id ?? crypto.randomUUID().slice(0, 8);
+    if (this.sessions.has(id)) {
+      return this.sessions.get(id);
+    }
+    if (this.sessions.size >= this.maxSessions) {
+      throw new Error(`Max sessions (${this.maxSessions}) reached`);
+    }
+    const session = {
+      id,
+      process: null,
+      eventBuffer: [],
+      eventCounter: 0,
+      label: opts.label ?? id,
+      cwd: opts.cwd ?? process.cwd(),
+      createdAt: Date.now(),
+      lastActivityAt: Date.now()
+    };
+    this.sessions.set(id, session);
+    return session;
+  }
+  /** Get a session by ID. */
+  getSession(id) {
+    return this.sessions.get(id);
+  }
+  /** Get or create a session (used for "default" backward compat). */
+  getOrCreateSession(id, opts) {
+    const existing = this.sessions.get(id);
+    if (existing) return existing;
+    return this.createSession({ id, ...opts });
+  }
+  /** Set the agent process for a session. Subscribes to events. */
+  setProcess(sessionId, proc) {
+    const session = this.sessions.get(sessionId);
+    if (!session) throw new Error(`Session "${sessionId}" not found`);
+    session.process = proc;
+    session.lastActivityAt = Date.now();
+    proc.on("event", (e) => {
+      session.eventBuffer.push(e);
+      session.eventCounter++;
+      if (session.eventBuffer.length > MAX_EVENT_BUFFER) {
+        session.eventBuffer.splice(0, session.eventBuffer.length - MAX_EVENT_BUFFER);
+      }
+    });
+  }
+  /** Kill the agent process in a session (session stays, can be restarted). */
+  killSession(id) {
+    const session = this.sessions.get(id);
+    if (!session?.process?.alive) return false;
+    session.process.kill();
+    return true;
+  }
+  /** Remove a session entirely. Cannot remove "default". */
+  removeSession(id) {
+    if (id === "default") return false;
+    const session = this.sessions.get(id);
+    if (!session) return false;
+    if (session.process?.alive) session.process.kill();
+    this.sessions.delete(id);
+    return true;
+  }
+  /** List all sessions as serializable info objects. */
+  listSessions() {
+    return Array.from(this.sessions.values()).map((s) => ({
+      id: s.id,
+      label: s.label,
+      alive: s.process?.alive ?? false,
+      cwd: s.cwd,
+      eventCount: s.eventCounter,
+      createdAt: s.createdAt,
+      lastActivityAt: s.lastActivityAt
+    }));
+  }
+  /** Touch a session's lastActivityAt timestamp. */
+  touch(id) {
+    const session = this.sessions.get(id);
+    if (session) session.lastActivityAt = Date.now();
+  }
+  /** Kill all sessions. Used during shutdown. */
+  killAll() {
+    for (const session of this.sessions.values()) {
+      if (session.process?.alive) {
+        session.process.kill();
+      }
+    }
+  }
+  get size() {
+    return this.sessions.size;
+  }
+}
+export {
+  SessionManager
+};