@haaaiawd/second-nature 0.1.4 → 0.1.6

package/index.js

@@ -1,4 +1,3 @@
-import { createRequire } from "node:module";
 function createFallbackCommands() {
     const commandNames = ["status", "policy", "credential", "quiet", "report", "session", "audit", "explain"];
     return commandNames.map((name) => ({
@@ -11,10 +10,9 @@ function createFallbackCommands() {
         }),
     }));
 }
-function resolveCommandRouterSafe() {
-    const require = createRequire(import.meta.url);
+async function resolveCommandRouterSafe() {
     try {
-        const mod = require("./runtime/cli/index.js");
+        const mod = await import("./runtime/cli/index.js");
         if (mod?.createCommandRouter) {
             return mod.createCommandRouter();
         }
@@ -30,10 +28,9 @@ function resolveCommandRouterSafe() {
         },
     };
 }
-function createRuntimeService() {
-    const require = createRequire(import.meta.url);
+async function createRuntimeService() {
     try {
-        const runtimeMod = require("./runtime/core/second-nature/runtime/service-entry.js");
+        const runtimeMod = await import("./runtime/core/second-nature/runtime/service-entry.js");
         if (runtimeMod?.startRuntimeService) {
             const handle = runtimeMod.startRuntimeService();
             return {
@@ -50,14 +47,13 @@ function createRuntimeService() {
     return {
         id: "second-nature-runtime",
         start() {
-            return { ready: true, version: "0.1.4-minimal" };
+            return { ready: true, version: "0.1.6-minimal" };
         },
     };
 }
-function createLifecycleService() {
-    const require = createRequire(import.meta.url);
+async function createLifecycleService() {
     try {
-        const lifecycleMod = require("./runtime/core/second-nature/runtime/lifecycle-service.js");
+        const lifecycleMod = await import("./runtime/core/second-nature/runtime/lifecycle-service.js");
         if (lifecycleMod?.recordRegistration) {
             return {
                 id: "second-nature-lifecycle",
@@ -84,10 +80,10 @@ export default {
     id: "second-nature",
     name: "Second Nature",
     description: "Registers command/tool/service surface with load-reload lifecycle semantics.",
-    register(api) {
-        const router = resolveCommandRouterSafe();
-        const runtimeService = createRuntimeService();
-        const lifecycleService = createLifecycleService();
+    async register(api) {
+        const router = await resolveCommandRouterSafe();
+        const runtimeService = await createRuntimeService();
+        const lifecycleService = await createLifecycleService();
         api.registerService(runtimeService);
         api.registerService(lifecycleService);
         api.registerCli(({ program }) => {

package/openclaw.plugin.json

@@ -1,7 +1,7 @@
 {
   "id": "second-nature",
   "name": "Second Nature",
-  "version": "0.1.4",
+  "version": "0.1.6",
   "entry": "./index.js",
   "description": "OpenClaw native plugin package for continuity, explain, and recovery operations.",
   "capabilities": {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@haaaiawd/second-nature",
-  "version": "0.1.4",
+  "version": "0.1.6",
   "description": "OpenClaw native plugin for long-running agent continuity, Quiet memory curation, and explainable operator flows.",
   "keywords": [
     "openclaw",
@@ -30,8 +30,8 @@
     ]
   },
   "dependencies": {
-    "better-sqlite3": "^11.10.0",
     "drizzle-orm": "^0.44.4",
+    "sql.js": "^1.14.1",
     "zod": "^4.1.5"
   }
 }

package/runtime/cli/action-bridge.js

@@ -15,11 +15,20 @@ export function createActionBridge(stateApi) {
             if (!answer.trim()) {
                 throw new Error("verification_answer_required");
             }
+            const credentialType = existing.credentialType ?? existing.credential_type;
+            const encryptedValue = existing.encryptedValue ?? existing.encrypted_value;
+            const expiresAt = existing.expiresAt ?? existing.expires_at;
+            const attemptsRemaining = existing.attemptsRemaining ?? existing.attempts_remaining;
+            const challengeText = existing.challengeText ?? existing.challenge_text;
             await stateApi.credentials.saveCredentialContext({
-                ...existing,
+                platformId: existing.platformId ?? existing.platform_id,
+                credentialType: credentialType ?? "",
+                encryptedValue: encryptedValue ?? "",
                 status: "active",
                 verificationCode: answer,
-                encryptedValue: existing.encryptedValue,
+                challengeText,
+                expiresAt,
+                attemptsRemaining,
                 updatedAt: new Date().toISOString(),
             });
         },

package/runtime/cli/read-models/index.js

@@ -59,7 +59,7 @@ export function createCliReadModels(deps) {
                 },
                 connectors: connectorSummary,
                 credentials: credentials.map((item) => ({
-                    platformId: item.platformId,
+                    platformId: item.platformId ?? item.platform_id,
                     status: item.status,
                     nextStep: buildCredentialNextStep(item.status),
                 })),
@@ -138,7 +138,7 @@ export function createCliReadModels(deps) {
                 };
             }
             return {
-                platformId: record.platformId,
+                platformId: record.platformId ?? record.platform_id,
                 status: record.status,
                 verificationDeadline: record.expiresAt ?? undefined,
                 attemptsRemaining: record.attemptsRemaining ?? undefined,

package/runtime/observability/db/index.d.ts

@@ -1,8 +1,8 @@
-import Database from "better-sqlite3";
-import { drizzle } from "drizzle-orm/better-sqlite3";
+import { type Database } from "sql.js";
+import { drizzle } from "drizzle-orm/sql-js";
 import * as schema from "./schema/index.js";
 export interface ObservabilityDatabase {
-    sqlite: Database.Database;
+    sqlite: Database;
     db: ReturnType<typeof drizzle<typeof schema>>;
     schema: typeof schema;
     close(): void;

package/runtime/observability/db/index.js

@@ -1,16 +1,41 @@
-import Database from "better-sqlite3";
-import { drizzle } from "drizzle-orm/better-sqlite3";
+import initSqlJs from "sql.js";
+import { drizzle } from "drizzle-orm/sql-js";
+import path from "node:path";
+import fs from "node:fs";
+import { fileURLToPath } from "node:url";
 import * as schema from "./schema/index.js";
-export function createObservabilityDatabase(filename = "./data/observability.db") {
-    const sqlite = new Database(filename);
-    sqlite.pragma("journal_mode = WAL");
-    sqlite.pragma("busy_timeout = 5000");
+// Pre-initialize sql.js WASM at module load time
+const SQL = await initSqlJs();
+function resolveDbPath(filename) {
+    if (path.isAbsolute(filename) || filename === ":memory:") {
+        return filename;
+    }
+    const __dirname = path.dirname(fileURLToPath(import.meta.url));
+    const pluginRoot = path.resolve(__dirname, "..", "..", "..");
+    const dataDir = path.join(pluginRoot, "data");
+    if (!fs.existsSync(dataDir)) {
+        fs.mkdirSync(dataDir, { recursive: true });
+    }
+    return path.join(dataDir, filename);
+}
+export function createObservabilityDatabase(filename = "observability.db") {
+    const dbPath = resolveDbPath(filename);
+    const isMemory = filename === ":memory:";
+    let dbBuffer;
+    if (!isMemory && fs.existsSync(dbPath)) {
+        dbBuffer = fs.readFileSync(dbPath);
+    }
+    const sqlite = new SQL.Database(dbBuffer);
     const db = drizzle(sqlite, { schema });
     return {
         sqlite,
         db,
         schema,
         close() {
+            if (!isMemory) {
+                const data = sqlite.export();
+                fs.writeFileSync(dbPath, Buffer.from(data));
+            }
             sqlite.close();
         },
     };

package/runtime/storage/db/index.d.ts

@@ -1,8 +1,8 @@
-import Database from "better-sqlite3";
-import { drizzle } from "drizzle-orm/better-sqlite3";
+import { type Database } from "sql.js";
+import { drizzle } from "drizzle-orm/sql-js";
 import * as schema from "./schema/index.js";
 export interface StateDatabase {
-    sqlite: Database.Database;
+    sqlite: Database;
     db: ReturnType<typeof drizzle<typeof schema>>;
     schema: typeof schema;
     close(): void;

package/runtime/storage/db/index.js

@@ -1,16 +1,41 @@
-import Database from "better-sqlite3";
-import { drizzle } from "drizzle-orm/better-sqlite3";
+import initSqlJs from "sql.js";
+import { drizzle } from "drizzle-orm/sql-js";
+import path from "node:path";
+import fs from "node:fs";
+import { fileURLToPath } from "node:url";
 import * as schema from "./schema/index.js";
-export function createStateDatabase(filename = "./data/state.db") {
-    const sqlite = new Database(filename);
-    sqlite.pragma("journal_mode = WAL");
-    sqlite.pragma("busy_timeout = 5000");
+// Pre-initialize sql.js WASM at module load time
+const SQL = await initSqlJs();
+function resolveDbPath(filename) {
+    if (path.isAbsolute(filename) || filename === ":memory:") {
+        return filename;
+    }
+    const __dirname = path.dirname(fileURLToPath(import.meta.url));
+    const pluginRoot = path.resolve(__dirname, "..", "..", "..");
+    const dataDir = path.join(pluginRoot, "data");
+    if (!fs.existsSync(dataDir)) {
+        fs.mkdirSync(dataDir, { recursive: true });
+    }
+    return path.join(dataDir, filename);
+}
+export function createStateDatabase(filename = "state.db") {
+    const dbPath = resolveDbPath(filename);
+    const isMemory = filename === ":memory:";
+    let dbBuffer;
+    if (!isMemory && fs.existsSync(dbPath)) {
+        dbBuffer = fs.readFileSync(dbPath);
+    }
+    const sqlite = new SQL.Database(dbBuffer);
     const db = drizzle(sqlite, { schema });
     return {
         sqlite,
         db,
         schema,
         close() {
+            if (!isMemory) {
+                const data = sqlite.export();
+                fs.writeFileSync(dbPath, Buffer.from(data));
+            }
             sqlite.close();
         },
     };

package/runtime/storage/services/repair-and-backup.js

@@ -55,7 +55,8 @@ export class RepairAndBackupService {
         await fs.mkdir(backupDir, { recursive: true });
         const backupFileName = `state-${now.toISOString().replace(/[:.]/g, "-")}.db`;
         const backupPath = path.join(backupDir, backupFileName);
-        await this.database.sqlite.backup(backupPath);
+        const dbData = this.database.sqlite.export();
+        await fs.writeFile(backupPath, Buffer.from(dbData));
         return {
             scannedAssetCount: assets.length,
             repairedOrphanIndexCount: repairedOrphanAssetIds.length,

package/runtime/storage/state-api.js

@@ -27,7 +27,17 @@ export class DefaultStateAPI {
         const personaCandidateLoader = createPersonaCandidateLoader();
         this.read = {
             loadQuietInputs: (query) => quietInputLoader.loadQuietInputs(query),
-            loadPolicy: (platformId) => policyRepository.findByPlatformId(platformId),
+            loadPolicy: async (platformId) => {
+                const record = await policyRepository.findByPlatformId(platformId);
+                if (!record)
+                    return undefined;
+                return {
+                    platformId: record.platformId ?? record.platform_id,
+                    socialDailyLimit: record.socialDailyLimit ?? record.social_daily_limit,
+                    quietEnabled: record.quietEnabled ?? Boolean(record.quiet_enabled),
+                    updatedAt: record.updatedAt ?? record.updated_at,
+                };
+            },
             loadPersonaCandidates: (sceneContext) => personaCandidateLoader.loadPersonaCandidates(sceneContext),
         };
         this.write = {
@@ -46,7 +56,21 @@ export class DefaultStateAPI {
         };
         this.credentials = {
             loadCredentialContext: async (platformId) => {
-                return credentialRepository.findByPlatformId(platformId);
+                const record = await credentialRepository.findByPlatformId(platformId);
+                if (!record)
+                    return null;
+                const r = record;
+                return {
+                    platformId: (r.platformId ?? r.platform_id),
+                    credentialType: (r.credentialType ?? r.credential_type),
+                    encryptedValue: (r.encryptedValue ?? r.encrypted_value),
+                    status: (r.status ?? ""),
+                    verificationCode: (r.verificationCode ?? r.verification_code ?? null),
+                    challengeText: (r.challengeText ?? r.challenge_text ?? null),
+                    expiresAt: (r.expiresAt ?? r.expires_at ?? null),
+                    attemptsRemaining: (r.attemptsRemaining ?? r.attempts_remaining ?? null),
+                    updatedAt: (r.updatedAt ?? r.updated_at ?? ""),
+                };
             },
             saveCredentialContext: async (input) => {
                 const ctx = input;