@sna-sdk/core 0.9.10 → 0.9.12

package/dist/electron/index.d.ts

@@ -1,5 +1,7 @@
 import { ChildProcess } from 'child_process';
+import http from 'http';
 export { ResolveResult, cacheClaudePath, parseCommandVOutput, resolveClaudeCli, validateClaudePath } from '../core/providers/claude-code.js';
+import { SessionManager } from '../server/session-manager.js';
 import '../core/providers/types.js';
 
 /**
@@ -102,5 +104,33 @@ interface SnaServerHandle {
  * Throws if the server fails to start within `options.readyTimeout`.
  */
 declare function startSnaServer(options: SnaServerOptions): Promise<SnaServerHandle>;
+interface InProcessSnaServerHandle {
+    /** No child process — the server runs in the calling process. */
+    process: null;
+    /** The port the server is listening on. */
+    port: number;
+    /** The session manager instance. */
+    sessionManager: SessionManager;
+    /** The underlying HTTP server. */
+    httpServer: http.Server;
+    /** Graceful shutdown: kill all sessions and close the HTTP server. */
+    stop(): Promise<void>;
+}
+/**
+ * Launch the SNA API server **in-process** (no fork).
+ *
+ * Designed for Electron main processes where fork() causes problems:
+ * - asar module resolution failures
+ * - PATH / env propagation issues
+ * - orphaned child processes on crash
+ *
+ * The server runs on the same Node.js event loop as the caller. Use `stop()`
+ * to tear down cleanly (e.g., in Electron's `before-quit` handler).
+ *
+ * Unlike fork mode, this does **not** spawn a default agent — the consumer
+ * controls session/agent lifecycle via the returned `sessionManager` or via
+ * the WebSocket / HTTP API.
+ */
+declare function startSnaServerInProcess(options: SnaServerOptions): Promise<InProcessSnaServerHandle>;
 
-export { type SnaServerHandle, type SnaServerOptions, startSnaServer };
+export { type InProcessSnaServerHandle, type SnaServerHandle, type SnaServerOptions, startSnaServer, startSnaServerInProcess };

package/dist/electron/index.js

@@ -3,6 +3,14 @@ import { fileURLToPath } from "url";
 import fs from "fs";
 import { resolveClaudeCli, validateClaudePath, cacheClaudePath, parseCommandVOutput } from "../core/providers/claude-code.js";
 import path from "path";
+import { Hono } from "hono";
+import { cors } from "hono/cors";
+import { serve } from "@hono/node-server";
+import { createSnaApp } from "../server/index.js";
+import { SessionManager } from "../server/session-manager.js";
+import { attachWebSocket } from "../server/ws.js";
+import { setConfig, getConfig } from "../config.js";
+import { getDb } from "../db/schema.js";
 function resolveStandaloneScript() {
   const selfPath = fileURLToPath(import.meta.url);
   let script = path.resolve(path.dirname(selfPath), "../server/standalone.js");
@@ -107,10 +115,82 @@ async function startSnaServer(options) {
     }
   };
 }
+async function startSnaServerInProcess(options) {
+  const port = options.port ?? 3099;
+  const cwd = options.cwd ?? path.dirname(options.dbPath);
+  setConfig({
+    port,
+    dbPath: options.dbPath,
+    ...options.maxSessions != null ? { maxSessions: options.maxSessions } : {},
+    ...options.permissionMode ? { defaultPermissionMode: options.permissionMode } : {},
+    ...options.model ? { model: options.model } : {},
+    ...options.permissionTimeoutMs != null ? { permissionTimeoutMs: options.permissionTimeoutMs } : {}
+  });
+  process.env.SNA_PORT = String(port);
+  process.env.SNA_DB_PATH = options.dbPath;
+  if (options.maxSessions != null) process.env.SNA_MAX_SESSIONS = String(options.maxSessions);
+  if (options.permissionMode) process.env.SNA_PERMISSION_MODE = options.permissionMode;
+  if (options.model) process.env.SNA_MODEL = options.model;
+  if (options.permissionTimeoutMs != null) process.env.SNA_PERMISSION_TIMEOUT_MS = String(options.permissionTimeoutMs);
+  if (options.nativeBinding) process.env.SNA_SQLITE_NATIVE_BINDING = options.nativeBinding;
+  if (!process.env.SNA_MODULES_PATH) {
+    try {
+      const bsPkg = require.resolve("better-sqlite3/package.json", { paths: [process.cwd()] });
+      process.env.SNA_MODULES_PATH = path.resolve(bsPkg, "../..");
+    } catch {
+    }
+  }
+  const originalCwd = process.cwd();
+  try {
+    process.chdir(cwd);
+  } catch {
+  }
+  try {
+    getDb();
+  } catch (err) {
+    process.chdir(originalCwd);
+    throw new Error(`SNA in-process: database init failed: ${err.message}`);
+  }
+  const config = getConfig();
+  const root = new Hono();
+  root.use("*", cors({ origin: "*", allowMethods: ["GET", "POST", "PATCH", "DELETE", "OPTIONS"] }));
+  root.onError((err, c) => {
+    const pathname = new URL(c.req.url).pathname;
+    if (options.onLog) options.onLog(`ERR ${c.req.method} ${pathname} \u2192 ${err.message}`);
+    return c.json({ status: "error", message: err.message, stack: err.stack }, 500);
+  });
+  root.use("*", async (c, next) => {
+    const m = c.req.method;
+    const pathname = new URL(c.req.url).pathname;
+    if (options.onLog) options.onLog(`${m.padEnd(6)} ${pathname}`);
+    await next();
+  });
+  const sessionManager = new SessionManager({ maxSessions: config.maxSessions });
+  root.route("/", createSnaApp({ sessionManager }));
+  const httpServer = serve({ fetch: root.fetch, port }, () => {
+    if (options.onLog) options.onLog(`API server ready \u2192 http://localhost:${port}`);
+    if (options.onLog) options.onLog(`WebSocket endpoint \u2192 ws://localhost:${port}/ws`);
+  });
+  attachWebSocket(httpServer, sessionManager);
+  return {
+    process: null,
+    port,
+    sessionManager,
+    httpServer,
+    async stop() {
+      sessionManager.killAll();
+      await new Promise((resolve) => {
+        httpServer.close(() => resolve());
+        setTimeout(() => resolve(), 3e3).unref();
+      });
+    }
+  };
+}
 export {
   cacheClaudePath,
   parseCommandVOutput,
   resolveClaudeCli,
   startSnaServer,
+  startSnaServerInProcess,
   validateClaudePath
 };

package/dist/node/index.cjs

@@ -39,14 +39,72 @@ var getImportMetaUrl = () => typeof document === "undefined" ? new URL(`file:${_
 var importMetaUrl = /* @__PURE__ */ getImportMetaUrl();
 
 // src/electron/index.ts
-var import_child_process = require("child_process");
-var import_url = require("url");
-var import_fs2 = __toESM(require("fs"), 1);
+var import_child_process2 = require("child_process");
+var import_url2 = require("url");
+var import_fs4 = __toESM(require("fs"), 1);
 
 // src/core/providers/claude-code.ts
+var import_child_process = require("child_process");
 var import_events = require("events");
+var import_fs3 = __toESM(require("fs"), 1);
+var import_path3 = __toESM(require("path"), 1);
+var import_url = require("url");
 
 // src/core/providers/cc-history-adapter.ts
+var import_fs = __toESM(require("fs"), 1);
+var import_path = __toESM(require("path"), 1);
+function writeHistoryJsonl(history, opts) {
+  for (let i = 1; i < history.length; i++) {
+    if (history[i].role === history[i - 1].role) {
+      throw new Error(
+        `History validation failed: consecutive ${history[i].role} at index ${i - 1} and ${i}. Messages must alternate user\u2194assistant. Merge tool results into text before injecting.`
+      );
+    }
+  }
+  try {
+    const dir = import_path.default.join(opts.cwd, ".sna", "history");
+    import_fs.default.mkdirSync(dir, { recursive: true });
+    const sessionId = crypto.randomUUID();
+    const filePath = import_path.default.join(dir, `${sessionId}.jsonl`);
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    const lines = [];
+    let prevUuid = null;
+    for (const msg of history) {
+      const uuid = crypto.randomUUID();
+      if (msg.role === "user") {
+        lines.push(JSON.stringify({
+          parentUuid: prevUuid,
+          isSidechain: false,
+          type: "user",
+          uuid,
+          timestamp: now,
+          cwd: opts.cwd,
+          sessionId,
+          message: { role: "user", content: msg.content }
+        }));
+      } else {
+        lines.push(JSON.stringify({
+          parentUuid: prevUuid,
+          isSidechain: false,
+          type: "assistant",
+          uuid,
+          timestamp: now,
+          cwd: opts.cwd,
+          sessionId,
+          message: {
+            role: "assistant",
+            content: [{ type: "text", text: msg.content }]
+          }
+        }));
+      }
+      prevUuid = uuid;
+    }
+    import_fs.default.writeFileSync(filePath, lines.join("\n") + "\n");
+    return { filePath, extraArgs: ["--resume", filePath] };
+  } catch {
+    return null;
+  }
+}
 function buildRecalledConversation(history) {
   const xml = history.map((msg) => `<${msg.role}>${msg.content}</${msg.role}>`).join("\n");
   return JSON.stringify({
@@ -61,11 +119,11 @@ ${xml}
 }
 
 // src/lib/logger.ts
-var import_fs = __toESM(require("fs"), 1);
-var import_path = __toESM(require("path"), 1);
-var LOG_PATH = import_path.default.join(process.cwd(), ".dev.log");
+var import_fs2 = __toESM(require("fs"), 1);
+var import_path2 = __toESM(require("path"), 1);
+var LOG_PATH = import_path2.default.join(process.cwd(), ".dev.log");
 try {
-  import_fs.default.writeFileSync(LOG_PATH, "");
+  import_fs2.default.writeFileSync(LOG_PATH, "");
 } catch {
 }
 function ts() {
@@ -84,7 +142,7 @@ var tags = {
 function appendFile(tag, args) {
   const line = `${ts()} ${tag} ${args.map((a) => typeof a === "string" ? a : JSON.stringify(a)).join(" ")}
 `;
-  import_fs.default.appendFile(LOG_PATH, line, () => {
+  import_fs2.default.appendFile(LOG_PATH, line, () => {
   });
 }
 function log(tag, ...args) {
@@ -99,6 +157,81 @@ var logger = { log, err };
 
 // src/core/providers/claude-code.ts
 var SHELL = process.env.SHELL || "/bin/zsh";
+function parseCommandVOutput(raw) {
+  const trimmed = raw.trim();
+  if (!trimmed) return "claude";
+  const aliasMatch = trimmed.match(/=\s*['"]?([^'"]+?)['"]?\s*$/);
+  if (aliasMatch) return aliasMatch[1];
+  const pathMatch = trimmed.match(/^(\/\S+)/m);
+  if (pathMatch) return pathMatch[1];
+  return trimmed;
+}
+function validateClaudePath(claudePath) {
+  try {
+    const claudeDir = import_path3.default.dirname(claudePath);
+    const env = { ...process.env, PATH: `${claudeDir}:${process.env.PATH ?? ""}` };
+    const out = (0, import_child_process.execSync)(`"${claudePath}" --version`, { encoding: "utf8", stdio: "pipe", timeout: 1e4, env }).trim();
+    return { ok: true, version: out.split("\n")[0].slice(0, 30) };
+  } catch {
+    return { ok: false };
+  }
+}
+function cacheClaudePath(claudePath, cacheDir) {
+  const dir = cacheDir ?? import_path3.default.join(process.cwd(), ".sna");
+  try {
+    if (!import_fs3.default.existsSync(dir)) import_fs3.default.mkdirSync(dir, { recursive: true });
+    import_fs3.default.writeFileSync(import_path3.default.join(dir, "claude-path"), claudePath);
+  } catch {
+  }
+}
+function resolveClaudeCli(opts) {
+  const cacheDir = opts?.cacheDir;
+  if (process.env.SNA_CLAUDE_COMMAND) {
+    const v = validateClaudePath(process.env.SNA_CLAUDE_COMMAND);
+    return { path: process.env.SNA_CLAUDE_COMMAND, version: v.version, source: "env" };
+  }
+  const cacheFile = cacheDir ? import_path3.default.join(cacheDir, "claude-path") : import_path3.default.join(process.cwd(), ".sna/claude-path");
+  try {
+    const cached = import_fs3.default.readFileSync(cacheFile, "utf8").trim();
+    if (cached) {
+      const v = validateClaudePath(cached);
+      if (v.ok) return { path: cached, version: v.version, source: "cache" };
+    }
+  } catch {
+  }
+  const staticPaths = [
+    "/opt/homebrew/bin/claude",
+    "/usr/local/bin/claude",
+    `${process.env.HOME}/.local/bin/claude`,
+    `${process.env.HOME}/.claude/bin/claude`,
+    `${process.env.HOME}/.volta/bin/claude`
+  ];
+  for (const p of staticPaths) {
+    const v = validateClaudePath(p);
+    if (v.ok) {
+      cacheClaudePath(p, cacheDir);
+      return { path: p, version: v.version, source: "static" };
+    }
+  }
+  try {
+    const raw = (0, import_child_process.execSync)(`${SHELL} -i -l -c "command -v claude" 2>/dev/null`, { encoding: "utf8", timeout: 5e3 }).trim();
+    const resolved = parseCommandVOutput(raw);
+    if (resolved && resolved !== "claude") {
+      const v = validateClaudePath(resolved);
+      if (v.ok) {
+        cacheClaudePath(resolved, cacheDir);
+        return { path: resolved, version: v.version, source: "shell" };
+      }
+    }
+  } catch {
+  }
+  return { path: "claude", source: "fallback" };
+}
+function resolveClaudePath(cwd) {
+  const result = resolveClaudeCli({ cacheDir: import_path3.default.join(cwd, ".sna") });
+  logger.log("agent", `claude path: ${result.source}=${result.path}${result.version ? ` (${result.version})` : ""}`);
+  return result.path;
+}
 var _ClaudeCodeProcess = class _ClaudeCodeProcess {
   constructor(proc, options) {
     this.emitter = new import_events.EventEmitter();
@@ -440,16 +573,203 @@ var _ClaudeCodeProcess = class _ClaudeCodeProcess {
 };
 _ClaudeCodeProcess.DRAIN_INTERVAL_MS = 15;
 var ClaudeCodeProcess = _ClaudeCodeProcess;
+var ClaudeCodeProvider = class {
+  constructor() {
+    this.name = "claude-code";
+  }
+  async isAvailable() {
+    try {
+      const p = resolveClaudePath(process.cwd());
+      (0, import_child_process.execSync)(`test -x "${p}"`, { stdio: "pipe" });
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  spawn(options) {
+    const claudeCommand = resolveClaudePath(options.cwd);
+    const claudeParts = claudeCommand.split(/\s+/);
+    const claudePath = claudeParts[0];
+    const claudePrefix = claudeParts.slice(1);
+    let pkgRoot = import_path3.default.dirname((0, import_url.fileURLToPath)(importMetaUrl));
+    while (!import_fs3.default.existsSync(import_path3.default.join(pkgRoot, "package.json"))) {
+      const parent = import_path3.default.dirname(pkgRoot);
+      if (parent === pkgRoot) break;
+      pkgRoot = parent;
+    }
+    const hookScript = import_path3.default.join(pkgRoot, "dist", "scripts", "hook.js");
+    const sessionId = options.env?.SNA_SESSION_ID ?? "default";
+    const sdkSettings = {};
+    if (options.permissionMode !== "bypassPermissions") {
+      sdkSettings.hooks = {
+        PreToolUse: [{
+          matcher: ".*",
+          hooks: [{ type: "command", command: `node "${hookScript}" --session=${sessionId}` }]
+        }]
+      };
+    }
+    let extraArgsClean = options.extraArgs ? [...options.extraArgs] : [];
+    const settingsIdx = extraArgsClean.indexOf("--settings");
+    if (settingsIdx !== -1 && settingsIdx + 1 < extraArgsClean.length) {
+      try {
+        const appSettings = JSON.parse(extraArgsClean[settingsIdx + 1]);
+        if (appSettings.hooks) {
+          for (const [event, hooks] of Object.entries(appSettings.hooks)) {
+            if (sdkSettings.hooks && sdkSettings.hooks[event]) {
+              sdkSettings.hooks[event] = [
+                ...sdkSettings.hooks[event],
+                ...hooks
+              ];
+            } else {
+              sdkSettings.hooks[event] = hooks;
+            }
+          }
+          delete appSettings.hooks;
+        }
+        Object.assign(sdkSettings, appSettings);
+      } catch {
+      }
+      extraArgsClean.splice(settingsIdx, 2);
+    }
+    const args = [
+      "--output-format",
+      "stream-json",
+      "--input-format",
+      "stream-json",
+      "--verbose",
+      "--include-partial-messages",
+      "--settings",
+      JSON.stringify(sdkSettings)
+    ];
+    if (options.model) {
+      args.push("--model", options.model);
+    }
+    if (options.permissionMode) {
+      args.push("--permission-mode", options.permissionMode);
+    }
+    if (options.history?.length && options.prompt) {
+      const result = writeHistoryJsonl(options.history, { cwd: options.cwd });
+      if (result) {
+        args.push(...result.extraArgs);
+        options._historyViaResume = true;
+        logger.log("agent", `history via JSONL resume \u2192 ${result.filePath}`);
+      }
+    }
+    if (extraArgsClean.length > 0) {
+      args.push(...extraArgsClean);
+    }
+    const cleanEnv = { ...process.env, ...options.env };
+    if (options.configDir) {
+      cleanEnv.CLAUDE_CONFIG_DIR = options.configDir;
+    }
+    delete cleanEnv.CLAUDECODE;
+    delete cleanEnv.CLAUDE_CODE_ENTRYPOINT;
+    delete cleanEnv.CLAUDE_CODE_SESSION_ACCESS_TOKEN;
+    delete cleanEnv.CLAUDE_CODE_OAUTH_TOKEN;
+    const claudeDir = import_path3.default.dirname(claudePath);
+    if (claudeDir && claudeDir !== ".") {
+      cleanEnv.PATH = `${claudeDir}:${cleanEnv.PATH ?? ""}`;
+    }
+    const proc = (0, import_child_process.spawn)(claudePath, [...claudePrefix, ...args], {
+      cwd: options.cwd,
+      env: cleanEnv,
+      stdio: ["pipe", "pipe", "pipe"]
+    });
+    logger.log("agent", `spawned claude-code (pid=${proc.pid}) \u2192 ${claudeCommand} ${args.join(" ")}`);
+    return new ClaudeCodeProcess(proc, options);
+  }
+};
+
+// src/electron/index.ts
+var import_path6 = __toESM(require("path"), 1);
+var import_hono4 = require("hono");
+var import_cors = require("hono/cors");
+var import_node_server = require("@hono/node-server");
+
+// src/server/index.ts
+var import_hono3 = require("hono");
+
+// src/server/routes/events.ts
+var import_streaming = require("hono/streaming");
+
+// src/db/schema.ts
+var import_node_module = require("module");
+var import_path4 = __toESM(require("path"), 1);
+var NATIVE_DIR = import_path4.default.join(process.cwd(), ".sna/native");
+
+// src/config.ts
+var defaults = {
+  port: 3099,
+  model: "claude-sonnet-4-6",
+  defaultProvider: "claude-code",
+  defaultPermissionMode: "default",
+  maxSessions: 5,
+  maxEventBuffer: 500,
+  permissionTimeoutMs: 0,
+  // app controls — no SDK-side timeout
+  runOnceTimeoutMs: 12e4,
+  pollIntervalMs: 500,
+  keepaliveIntervalMs: 15e3,
+  skillPollMs: 2e3,
+  dbPath: "data/sna.db"
+};
+function fromEnv() {
+  const env = {};
+  if (process.env.SNA_PORT) env.port = parseInt(process.env.SNA_PORT, 10);
+  if (process.env.SNA_MODEL) env.model = process.env.SNA_MODEL;
+  if (process.env.SNA_PERMISSION_MODE) env.defaultPermissionMode = process.env.SNA_PERMISSION_MODE;
+  if (process.env.SNA_MAX_SESSIONS) env.maxSessions = parseInt(process.env.SNA_MAX_SESSIONS, 10);
+  if (process.env.SNA_DB_PATH) env.dbPath = process.env.SNA_DB_PATH;
+  if (process.env.SNA_PERMISSION_TIMEOUT_MS) env.permissionTimeoutMs = parseInt(process.env.SNA_PERMISSION_TIMEOUT_MS, 10);
+  return env;
+}
+var current = { ...defaults, ...fromEnv() };
+
+// src/server/routes/run.ts
+var import_streaming2 = require("hono/streaming");
+var ROOT = process.cwd();
+
+// src/server/routes/agent.ts
+var import_hono = require("hono");
+var import_streaming3 = require("hono/streaming");
+
+// src/core/providers/codex.ts
+var CodexProvider = class {
+  constructor() {
+    this.name = "codex";
+  }
+  async isAvailable() {
+    return false;
+  }
+  spawn(_options) {
+    throw new Error("Codex provider not yet implemented");
+  }
+};
+
+// src/core/providers/index.ts
+var providers = {
+  "claude-code": new ClaudeCodeProvider(),
+  "codex": new CodexProvider()
+};
+
+// src/server/image-store.ts
+var import_path5 = __toESM(require("path"), 1);
+var IMAGE_DIR = import_path5.default.join(process.cwd(), "data/images");
+
+// src/server/routes/chat.ts
+var import_hono2 = require("hono");
+
+// src/server/ws.ts
+var import_ws = require("ws");
 
 // src/electron/index.ts
-var import_path2 = __toESM(require("path"), 1);
 function resolveStandaloneScript() {
-  const selfPath = (0, import_url.fileURLToPath)(importMetaUrl);
-  let script = import_path2.default.resolve(import_path2.default.dirname(selfPath), "../server/standalone.js");
+  const selfPath = (0, import_url2.fileURLToPath)(importMetaUrl);
+  let script = import_path6.default.resolve(import_path6.default.dirname(selfPath), "../server/standalone.js");
   if (script.includes(".asar") && !script.includes(".asar.unpacked")) {
     script = script.replace(/(\.asar)([/\\])/, ".asar.unpacked$2");
   }
-  if (!import_fs2.default.existsSync(script)) {
+  if (!import_fs4.default.existsSync(script)) {
     throw new Error(
       `SNA standalone script not found: ${script}
 Ensure "@sna-sdk/core" is listed in asarUnpack in your electron-builder config.`
@@ -460,14 +780,14 @@ Ensure "@sna-sdk/core" is listed in asarUnpack in your electron-builder config.`
 function buildNodePath() {
   const resourcesPath = process.resourcesPath;
   if (!resourcesPath) return void 0;
-  const unpacked = import_path2.default.join(resourcesPath, "app.asar.unpacked", "node_modules");
-  if (!import_fs2.default.existsSync(unpacked)) return void 0;
+  const unpacked = import_path6.default.join(resourcesPath, "app.asar.unpacked", "node_modules");
+  if (!import_fs4.default.existsSync(unpacked)) return void 0;
   const existing = process.env.NODE_PATH;
-  return existing ? `${unpacked}${import_path2.default.delimiter}${existing}` : unpacked;
+  return existing ? `${unpacked}${import_path6.default.delimiter}${existing}` : unpacked;
 }
 async function startSnaServer(options) {
   const port = options.port ?? 3099;
-  const cwd = options.cwd ?? import_path2.default.dirname(options.dbPath);
+  const cwd = options.cwd ?? import_path6.default.dirname(options.dbPath);
   const readyTimeout = options.readyTimeout ?? 15e3;
   const { onLog } = options;
   const standaloneScript = resolveStandaloneScript();
@@ -475,7 +795,7 @@ async function startSnaServer(options) {
   let consumerModules;
   try {
     const bsPkg = require.resolve("better-sqlite3/package.json", { paths: [process.cwd()] });
-    consumerModules = import_path2.default.resolve(bsPkg, "../..");
+    consumerModules = import_path6.default.resolve(bsPkg, "../..");
   } catch {
   }
   const env = {
@@ -492,7 +812,7 @@ async function startSnaServer(options) {
     // Consumer overrides last so they can always win
     ...options.env ?? {}
   };
-  const proc = (0, import_child_process.fork)(standaloneScript, [], {
+  const proc = (0, import_child_process2.fork)(standaloneScript, [], {
     cwd,
     env,
     stdio: "pipe"

package/dist/node/index.d.ts

@@ -1,4 +1,6 @@
 export { SnaServerHandle, SnaServerOptions, startSnaServer } from '../electron/index.js';
 import 'child_process';
+import 'http';
 import '../core/providers/claude-code.js';
 import '../core/providers/types.js';
+import '../server/session-manager.js';

package/dist/server/standalone.js

@@ -13,7 +13,9 @@ import { streamSSE } from "hono/streaming";
 import { createRequire } from "module";
 import fs from "fs";
 import path from "path";
-var DB_PATH = process.env.SNA_DB_PATH ?? path.join(process.cwd(), "data/sna.db");
+function getDbPath() {
+  return process.env.SNA_DB_PATH ?? path.join(process.cwd(), "data/sna.db");
+}
 var NATIVE_DIR = path.join(process.cwd(), ".sna/native");
 var _db = null;
 function loadBetterSqlite3() {
@@ -36,10 +38,10 @@ function loadBetterSqlite3() {
 function getDb() {
   if (!_db) {
     const BetterSqlite3 = loadBetterSqlite3();
-    const dir = path.dirname(DB_PATH);
+    const dir = path.dirname(getDbPath());
     if (!fs.existsSync(dir)) fs.mkdirSync(dir, { recursive: true });
     const nativeBinding = process.env.SNA_SQLITE_NATIVE_BINDING || void 0;
-    _db = nativeBinding ? new BetterSqlite3(DB_PATH, { nativeBinding }) : new BetterSqlite3(DB_PATH);
+    _db = nativeBinding ? new BetterSqlite3(getDbPath(), { nativeBinding }) : new BetterSqlite3(getDbPath());
     _db.pragma("journal_mode = WAL");
     initSchema(_db);
   }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sna-sdk/core",
-  "version": "0.9.10",
+  "version": "0.9.12",
   "description": "Skills-Native Application runtime — server, providers, session management, database, and CLI",
   "type": "module",
   "bin": {