@nothumanwork/nn 0.1.1 → 0.1.3

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nothumanwork/nn",
-  "version": "0.1.1",
+  "version": "0.1.3",
   "description": "Neural Net — multi-provider transcript fabric for AI coding agents",
   "type": "module",
   "license": "MIT",
@@ -53,13 +53,13 @@
     "@libsql/client": "^0.17.3"
   },
   "optionalDependencies": {
-    "@nothumanwork/nn-darwin-arm64": "0.1.1",
-    "@nothumanwork/nn-darwin-x64": "0.1.1",
-    "@nothumanwork/nn-linux-arm64-gnu": "0.1.1",
-    "@nothumanwork/nn-linux-arm64-musl": "0.1.1",
-    "@nothumanwork/nn-linux-x64-gnu": "0.1.1",
-    "@nothumanwork/nn-linux-x64-musl": "0.1.1",
-    "@nothumanwork/nn-win32-x64": "0.1.1"
+    "@nothumanwork/nn-darwin-arm64": "0.1.3",
+    "@nothumanwork/nn-darwin-x64": "0.1.3",
+    "@nothumanwork/nn-linux-arm64-gnu": "0.1.3",
+    "@nothumanwork/nn-linux-arm64-musl": "0.1.3",
+    "@nothumanwork/nn-linux-x64-gnu": "0.1.3",
+    "@nothumanwork/nn-linux-x64-musl": "0.1.3",
+    "@nothumanwork/nn-win32-x64": "0.1.3"
   },
   "devDependencies": {
     "@libsql/darwin-arm64": "0.5.29",

package/src/db/client.ts

@@ -235,33 +235,53 @@ export async function getSessionEvents(sessionId: string): Promise<
     sourceSessionId: string;
   }>
 > {
-  return withDb(async (client) => {
-    const result = await client.execute({
-      sql: `SELECT e.seq, e.boundary, e.role, e.timestamp, e.content_text, e.tool_name,
-                   e.tool_call_id, e.tool_input_json, e.tool_output_json, e.raw_json,
-                   s.source, s.source_session_id
-            FROM events e
-            JOIN sessions s ON s.id = e.session_id
-            WHERE e.session_id = ?
-            ORDER BY e.seq ASC`,
-      args: [sessionId],
-    });
-    return result.rows.map((row) => ({
-      seq: Number(row.seq),
-      boundary: String(row.boundary),
-      role: String(row.role),
-      timestamp: String(row.timestamp),
-      contentText: String(row.content_text),
-      toolName: row.tool_name ? String(row.tool_name) : null,
-      toolCallId: row.tool_call_id ? String(row.tool_call_id) : null,
-      toolInputJson: row.tool_input_json ? String(row.tool_input_json) : null,
-      toolOutputJson:
-        row.tool_output_json ? String(row.tool_output_json) : null,
-      rawJson: String(row.raw_json),
-      source: String(row.source) as ProviderId,
-      sourceSessionId: String(row.source_session_id),
-    }));
+  return withDb(async (client) => getSessionEventsWithClient(client, sessionId));
+}
+
+export async function getSessionEventsWithClient(
+  client: Client,
+  sessionId: string,
+): Promise<
+  Array<{
+    seq: number;
+    boundary: string;
+    role: string;
+    timestamp: string;
+    contentText: string;
+    toolName: string | null;
+    toolCallId: string | null;
+    toolInputJson: string | null;
+    toolOutputJson: string | null;
+    rawJson: string;
+    source: ProviderId;
+    sourceSessionId: string;
+  }>
+> {
+  const result = await client.execute({
+    sql: `SELECT e.seq, e.boundary, e.role, e.timestamp, e.content_text, e.tool_name,
+                 e.tool_call_id, e.tool_input_json, e.tool_output_json, e.raw_json,
+                 s.source, s.source_session_id
+          FROM events e
+          JOIN sessions s ON s.id = e.session_id
+          WHERE e.session_id = ?
+          ORDER BY e.seq ASC`,
+    args: [sessionId],
   });
+  return result.rows.map((row) => ({
+    seq: Number(row.seq),
+    boundary: String(row.boundary),
+    role: String(row.role),
+    timestamp: String(row.timestamp),
+    contentText: String(row.content_text),
+    toolName: row.tool_name ? String(row.tool_name) : null,
+    toolCallId: row.tool_call_id ? String(row.tool_call_id) : null,
+    toolInputJson: row.tool_input_json ? String(row.tool_input_json) : null,
+    toolOutputJson:
+      row.tool_output_json ? String(row.tool_output_json) : null,
+    rawJson: String(row.raw_json),
+    source: String(row.source) as ProviderId,
+    sourceSessionId: String(row.source_session_id),
+  }));
 }
 
 export async function searchEvents(
@@ -301,21 +321,39 @@ export async function recordExport(
   lossy: boolean,
   warnings: string[],
 ): Promise<void> {
-  await withDb(async (client) => {
-    const id = `exp:v1:${contentHash(`${sessionId}|${targetProvider}|${outputPath}|${Date.now()}`)}`;
-    await client.execute({
-      sql: `INSERT INTO exports(id, session_id, target_provider, output_path, exported_at, lossy, warnings_json)
-            VALUES (?, ?, ?, ?, ?, ?, ?)`,
-      args: [
-        id,
-        sessionId,
-        targetProvider,
-        outputPath,
-        Date.now(),
-        lossy ? 1 : 0,
-        JSON.stringify(warnings),
-      ],
-    });
+  await withDb(async (client) =>
+    recordExportWithClient(
+      client,
+      sessionId,
+      targetProvider,
+      outputPath,
+      lossy,
+      warnings,
+    ),
+  );
+}
+
+export async function recordExportWithClient(
+  client: Client,
+  sessionId: string,
+  targetProvider: string,
+  outputPath: string,
+  lossy: boolean,
+  warnings: string[],
+): Promise<void> {
+  const id = `exp:v1:${contentHash(`${sessionId}|${targetProvider}|${outputPath}|${Date.now()}`)}`;
+  await client.execute({
+    sql: `INSERT INTO exports(id, session_id, target_provider, output_path, exported_at, lossy, warnings_json)
+          VALUES (?, ?, ?, ?, ?, ?, ?)`,
+    args: [
+      id,
+      sessionId,
+      targetProvider,
+      outputPath,
+      Date.now(),
+      lossy ? 1 : 0,
+      JSON.stringify(warnings),
+    ],
   });
 }
 

package/src/db/migrate.ts

@@ -5,6 +5,7 @@ import { dirname } from "node:path";
 import { syncConfig, tursoConfigured } from "../config/sync.ts";
 import { dbPath } from "../config/paths.ts";
 import { checksum, readSchemaSql, withIngestLock } from "./lock.ts";
+import { ensureLocalReplicaIdentity } from "./replica-identity.ts";
 import {
   findPendingBackup,
   importedBackupDir,
@@ -44,15 +45,7 @@ export async function withDb<T>(
 ): Promise<T> {
   return withIngestLock(async () => {
     if (tursoConfigured()) {
-      const client = await openDbClient();
-      activeDbClient = client;
-      try {
-        return await fn(client);
-      } finally {
-        client.close();
-        activeDbClient = null;
-        resetDbCache();
-      }
+      return runEmbeddedReplicaOp(fn);
     }
 
     const client = await getDb();
@@ -60,6 +53,31 @@ export async function withDb<T>(
   });
 }
 
+async function runEmbeddedReplicaOp<T>(
+  fn: (client: Client) => Promise<T>,
+  allowRecovery = true,
+): Promise<T> {
+  const path = dbPath();
+
+  try {
+    const client = await openDbClient(path, false);
+    activeDbClient = client;
+    try {
+      return await fn(client);
+    } finally {
+      client.close();
+      activeDbClient = null;
+      resetDbCache();
+    }
+  } catch (error) {
+    if (allowRecovery && isReplicaConflictError(error)) {
+      recoverEmbeddedReplica(path);
+      return runEmbeddedReplicaOp(fn, false);
+    }
+    throw error;
+  }
+}
+
 export async function getDb(): Promise<Client> {
   if (activeDbClient) {
     return activeDbClient;
@@ -76,6 +94,8 @@ async function openDbClient(
   path = dbPath(),
   allowRecovery = true,
 ): Promise<Client> {
+  ensureLocalReplicaIdentity(path);
+
   try {
     const client = createDbClient(path);
     try {

package/src/db/replica-identity.ts

@@ -0,0 +1,62 @@
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { hostname } from "node:os";
+import { dirname } from "node:path";
+
+import { recoverEmbeddedReplica, replicaInfoPath } from "./replica-migrate.ts";
+
+const IDENTITY_BASENAME = "replica-identity.json";
+
+interface ReplicaIdentity {
+  host: string;
+  pid: number;
+  updatedAt: number;
+}
+
+function identityPath(dbPath: string): string {
+  return `${dirname(dbPath)}/${IDENTITY_BASENAME}`;
+}
+
+function readIdentity(dbPath: string): ReplicaIdentity | null {
+  const path = identityPath(dbPath);
+  if (!existsSync(path)) {
+    return null;
+  }
+  try {
+    return JSON.parse(readFileSync(path, "utf-8")) as ReplicaIdentity;
+  } catch {
+    return null;
+  }
+}
+
+function writeIdentity(dbPath: string): void {
+  const path = identityPath(dbPath);
+  mkdirSync(dirname(path), { recursive: true });
+  const identity: ReplicaIdentity = {
+    host: hostname(),
+    pid: process.pid,
+    updatedAt: Date.now(),
+  };
+  writeFileSync(path, `${JSON.stringify(identity, null, 2)}\n`, "utf-8");
+}
+
+/** Reset embedded replica when local files came from another machine (e.g. git clone). */
+export function ensureLocalReplicaIdentity(dbPath: string): boolean {
+  if (!existsSync(replicaInfoPath(dbPath))) {
+    writeIdentity(dbPath);
+    return false;
+  }
+
+  const identity = readIdentity(dbPath);
+  const host = hostname();
+  if (identity && identity.host !== host) {
+    console.error(
+      `[nn-db] embedded replica belongs to host "${identity.host}"; resetting for "${host}"`,
+    );
+    recoverEmbeddedReplica(dbPath);
+    writeIdentity(dbPath);
+    return true;
+  }
+
+  writeIdentity(dbPath);
+  return false;
+}

package/src/export/registry.ts

@@ -1,9 +1,12 @@
 import { mkdirSync, writeFileSync } from "node:fs";
 import { dirname } from "node:path";
 
-import { recordExport } from "../db/client.ts";
-import { getSessionEvents } from "../db/client.ts";
+import {
+  getSessionEventsWithClient,
+  recordExportWithClient,
+} from "../db/client.ts";
 import { findSessionBySourceId } from "../db/client.ts";
+import { withDb } from "../db/migrate.ts";
 import type { ProviderId } from "../ir/types.ts";
 import { claudeExporter } from "./claude.ts";
 import { codexExporter } from "./codex.ts";
@@ -47,61 +50,60 @@ export async function exportSession(
   manifestPath: string | null;
   manifest: ExportManifest;
 }> {
-  const events = await getSessionEvents(sessionId);
-  if (events.length === 0) {
-    throw new Error(`No events found for session ${sessionId}`);
-  }
+  return withDb(async (client) => {
+    const events = await getSessionEventsWithClient(client, sessionId);
+    if (events.length === 0) {
+      throw new Error(`No events found for session ${sessionId}`);
+    }
 
-  const resolvedTarget = target ?? events[0]!.source;
-  const exporter = getExporter(resolvedTarget);
-  const result = exporter.export({
-    sessionId,
-    source: events[0]!.source,
-    sourceSessionId: events[0]!.sourceSessionId,
-    events,
-  });
+    const resolvedTarget = target ?? events[0]!.source;
+    const exporter = getExporter(resolvedTarget);
+    const result = exporter.export({
+      sessionId,
+      source: events[0]!.source,
+      sourceSessionId: events[0]!.sourceSessionId,
+      events,
+    });
 
-  const content = result.lines.length > 0 ? `${result.lines.join("\n")}\n` : "";
+    const content =
+      result.lines.length > 0 ? `${result.lines.join("\n")}\n` : "";
 
-  const manifest: ExportManifest = {
-    source: events[0]!.source,
-    target: resolvedTarget,
-    sessionId,
-    sourceSessionId: events[0]!.sourceSessionId,
-    lossy: result.lossy,
-    warnings: result.warnings.map((warning) => warning.message),
-    exportedAt: new Date().toISOString(),
-    lineCount: result.lines.length,
-  };
+    const manifest: ExportManifest = {
+      source: events[0]!.source,
+      target: resolvedTarget,
+      sessionId,
+      sourceSessionId: events[0]!.sourceSessionId,
+      lossy: result.lossy,
+      warnings: result.warnings.map((warning) => warning.message),
+      exportedAt: new Date().toISOString(),
+      lineCount: result.lines.length,
+    };
 
-  if (!outputPath) {
-    await recordExport(
+    const resolvedOutputPath = outputPath ?? "-";
+    await recordExportWithClient(
+      client,
       sessionId,
       resolvedTarget,
-      "-",
+      resolvedOutputPath,
       result.lossy,
       manifest.warnings,
     );
-    return { content, outputPath: null, manifestPath: null, manifest };
-  }
 
-  mkdirSync(dirname(outputPath), { recursive: true });
-  writeFileSync(outputPath, content, "utf-8");
+    if (!outputPath) {
+      return { content, outputPath: null, manifestPath: null, manifest };
+    }
+
+    mkdirSync(dirname(outputPath), { recursive: true });
+    writeFileSync(outputPath, content, "utf-8");
 
-  const manifestPath = manifestPathFor(outputPath);
-  writeFileSync(
-    manifestPath,
-    `${JSON.stringify(manifest, null, 2)}\n`,
-    "utf-8",
-  );
-  await recordExport(
-    sessionId,
-    resolvedTarget,
-    outputPath,
-    result.lossy,
-    manifest.warnings,
-  );
-  return { content, outputPath, manifestPath, manifest };
+    const manifestPath = manifestPathFor(outputPath);
+    writeFileSync(
+      manifestPath,
+      `${JSON.stringify(manifest, null, 2)}\n`,
+      "utf-8",
+    );
+    return { content, outputPath, manifestPath, manifest };
+  });
 }
 
 export async function resolveSessionId(