@snoai/mem-claude 1.2.4 → 1.2.6

package/README.md

@@ -29,8 +29,7 @@ start of every session.
 2. Install the plugin (Node.js 22.22.3+, 24.15.0+ or 25.9.0+, and `git`):
 
    ```bash
-   sh -c 'sno_installer_body=$(curl -fsSL https://sno.ai/install) && printf "%s\n" "$sno_installer_body" | sh'
-   sno setup --harness claude
+   sh -c 'sno_installer_body=$(curl -fsSL https://sno.ai/install) && printf "%s\n" "$sno_installer_body" | sh' && ~/.local/bin/sno setup --harness claude
    ```
 
 3. Open a new Claude Code session inside a git repository, then try it:

package/dist/cli.js

@@ -4,7 +4,7 @@ import { isAbsolute, join } from "node:path";
 import { doctor } from "./doctor.js";
 import { correctCommand, getCommand, recallCommand, rememberCommand } from "./explicit.js";
 import { postToolUse, preToolUse, sessionEnd, sessionStart, stop, userPromptSubmit } from "./hooks.js";
-import { installClaude } from "./install.js";
+import { installClaude, uninstallClaude } from "./install.js";
 import { importRepository } from "./import.js";
 import { MESSAGES } from "./messages.js";
 import { workspaceRoot } from "./scope.js";
@@ -20,30 +20,35 @@ function option(args, name) {
     const index = args.indexOf(name);
     return index >= 0 ? args[index + 1] : undefined;
 }
+const HOOK_COMMANDS = ["session-start", "user-prompt-submit", "stop", "session-end", "pre-tool-use", "post-tool-use"];
 async function main() {
     const [command, ...args] = process.argv.slice(2);
+    const input = HOOK_COMMANDS.includes(command ?? "") ? await readStdin() : undefined;
+    // The Cursor IDE runs Claude Code hooks with Cursor-shaped input; Sno's Cursor hooks own Cursor, so these do nothing there.
+    if (input && typeof input === "object" && "cursor_version" in input)
+        return 0;
     if (command === "session-start") {
-        process.stdout.write(`${await sessionStart(await readStdin())}\n`);
+        process.stdout.write(`${await sessionStart(input)}\n`);
         return 0;
     }
     if (command === "user-prompt-submit") {
-        process.stdout.write(`${await userPromptSubmit(await readStdin())}\n`);
+        process.stdout.write(`${await userPromptSubmit(input)}\n`);
         return 0;
     }
     if (command === "stop") {
-        await stop(await readStdin());
+        await stop(input);
         return 0;
     }
     if (command === "session-end") {
-        await sessionEnd(await readStdin());
+        await sessionEnd(input);
         return 0;
     }
     if (command === "pre-tool-use") {
-        await preToolUse(await readStdin());
+        await preToolUse(input);
         return 0;
     }
     if (command === "post-tool-use") {
-        await postToolUse(await readStdin());
+        await postToolUse(input);
         return 0;
     }
     if (command === "worker") {
@@ -65,6 +70,13 @@ async function main() {
         });
         return 0;
     }
+    if (command === "uninstall") {
+        const configDir = option(args, "--config-dir");
+        if (!configDir || !isAbsolute(configDir))
+            throw new Error("--config-dir must be absolute");
+        await uninstallClaude({ configDir, writeOutput: line => process.stdout.write(`${line}\n`) });
+        return 0;
+    }
     if (command === "import") {
         const repo = option(args, "--repo");
         if (args.includes("--user") || !repo || !isAbsolute(repo))

package/dist/files.js

@@ -2,7 +2,7 @@ import { randomUUID } from "node:crypto";
 import { constants } from "node:fs";
 import { chmod, mkdir, open, readFile, rename, stat, unlink, writeFile } from "node:fs/promises";
 import { dirname } from "node:path";
-import locking from "fs-ext";
+import { tryLock, unlock } from "fs-native-extensions";
 export async function writeJsonAtomic(path, value) {
     await mkdir(dirname(path), { recursive: true, mode: 0o700 });
     const temporary = `${path}.${process.pid}.${randomUUID()}.tmp`;
@@ -10,6 +10,15 @@ export async function writeJsonAtomic(path, value) {
     await chmod(temporary, 0o600);
     await rename(temporary, path);
 }
+function alive(pid) {
+    try {
+        process.kill(pid, 0);
+        return true;
+    }
+    catch (error) {
+        return error instanceof Error && "code" in error && error.code === "EPERM";
+    }
+}
 export async function acquirePidFileLock(path, staleAfterMs) {
     await mkdir(dirname(path), { recursive: true, mode: 0o700 });
     const reclaimPath = `${path}.reclaim`;
@@ -18,7 +27,7 @@ export async function acquirePidFileLock(path, staleAfterMs) {
     const closeGuard = async () => {
         try {
             if (held)
-                locking.flockSync(guard.fd, "un");
+                unlock(guard.fd);
         }
         finally {
             held = false;
@@ -28,16 +37,10 @@ export async function acquirePidFileLock(path, staleAfterMs) {
     try {
         if (!(await guard.stat()).isFile())
             throw new Error("Lock guard is not a regular file");
-        try {
-            locking.flockSync(guard.fd, "exnb");
-            held = true;
-        }
-        catch (error) {
-            if (error instanceof Error && "code" in error && (error.code === "EAGAIN" || error.code === "EWOULDBLOCK")) {
-                await closeGuard();
-                return undefined;
-            }
-            throw error;
+        held = tryLock(guard.fd);
+        if (!held) {
+            await closeGuard();
+            return undefined;
         }
         const [contents, lockStat] = await Promise.all([
             readFile(path, "utf8").catch(() => undefined),
@@ -47,6 +50,14 @@ export async function acquirePidFileLock(path, staleAfterMs) {
             await closeGuard();
             return undefined;
         }
+        // A holder from before an upgrade took its guard with flock, which this lock cannot see on Linux; its fresh pid
+        // file is the only sign it still runs.
+        const holder = Number(contents?.split(" ")[0]);
+        if (Number.isInteger(holder) && holder > 0 && holder !== process.pid && lockStat
+            && Date.now() - lockStat.mtimeMs <= staleAfterMs && alive(holder)) {
+            await closeGuard();
+            return undefined;
+        }
         await unlink(path).catch(error => {
             if (!(error instanceof Error && "code" in error && error.code === "ENOENT"))
                 throw error;

package/dist/install.d.ts

@@ -21,5 +21,9 @@ export interface InstallOptions {
 export declare function isOwnedHookCommand(command: string, subcommand: string): boolean;
 export declare function isOwnedPermissionRule(rule: string): boolean;
 export declare function readSettings(configDir: string): Promise<Settings | undefined>;
+export declare function uninstallClaude(options: {
+    configDir: string;
+    writeOutput: (line: string) => void;
+}): Promise<void>;
 export declare function installClaude(options: InstallOptions): Promise<void>;
 export {};

package/dist/install.js

@@ -1,6 +1,6 @@
-import { mkdir, readFile, writeFile } from "node:fs/promises";
+import { mkdir, readFile, rm, writeFile } from "node:fs/promises";
 import { basename, dirname, isAbsolute, join } from "node:path";
-import { CODING_SKIN_HOOKS, codingSkinHookCommand, isCodingSkinHookCommand, shellQuote, } from "@snoai/memory/coding-skin";
+import { CODING_SKIN_HOOKS, codingSkinHookCommand, isCodingSkinHookCommand, snoProgramPath, shellQuote, } from "@snoai/memory/coding-skin";
 import { z } from "zod";
 import { APP_NAME } from "./constants.js";
 import { MESSAGES } from "./messages.js";
@@ -35,7 +35,7 @@ export function isOwnedPermissionRule(rule) {
         return false;
     const body = rule.slice(5, -3);
     if (body.endsWith(" memory"))
-        return basename(body.slice(0, -" memory".length)) === "sno";
+        return basename(snoProgramPath(body.slice(0, -" memory".length))) === "sno";
     return isAbsolute(body) && isOwnedProgram(body);
 }
 export async function readSettings(configDir) {
@@ -95,9 +95,41 @@ function updateSettings(settings, programPath) {
     if (index < 0)
         allow.push(rule);
     else
-        allow[index] = rule;
+        allow.splice(index, allow.length - index, rule, ...allow.slice(index + 1).filter(current => !isOwnedPermissionRule(current)));
     settings.permissions.allow = allow;
 }
+// Removes the hooks, rule and skill installClaude wrote; every other setting stays as it was.
+export async function uninstallClaude(options) {
+    const settings = await readSettings(options.configDir);
+    if (!settings)
+        throw new Error(MESSAGES.settingsUnparsable);
+    const before = JSON.stringify(settings);
+    for (const event of Object.keys(CODING_SKIN_HOOKS)) {
+        const groups = settings.hooks?.[event];
+        if (!settings.hooks || !groups)
+            continue;
+        const kept = groups.map(group => ({ ...group, hooks: group.hooks.filter(hook => !hook.command || !isOwnedHookCommand(hook.command, CODING_SKIN_HOOKS[event].subcommand)) }))
+            .filter(group => group.hooks.length > 0);
+        if (kept.length)
+            settings.hooks[event] = kept;
+        else
+            delete settings.hooks[event];
+    }
+    if (settings.hooks && Object.keys(settings.hooks).length === 0)
+        delete settings.hooks;
+    if (settings.permissions?.allow) {
+        settings.permissions.allow = settings.permissions.allow.filter(rule => !isOwnedPermissionRule(rule));
+        if (settings.permissions.allow.length === 0)
+            delete settings.permissions.allow;
+        if (Object.keys(settings.permissions).length === 0)
+            delete settings.permissions;
+    }
+    if (JSON.stringify(settings) !== before) {
+        await writeFile(join(options.configDir, "settings.json"), `${JSON.stringify(settings, null, 2)}\n`, { mode: 0o600 });
+    }
+    await rm(join(options.configDir, "skills", APP_NAME), { recursive: true, force: true });
+    options.writeOutput(MESSAGES.uninstallComplete);
+}
 export async function installClaude(options) {
     const settings = await readSettings(options.configDir);
     const writes = [{
@@ -105,7 +137,7 @@ export async function installClaude(options) {
             content: await readFile(new URL(`../skills/${APP_NAME}/SKILL.md`, import.meta.url), "utf8"),
         }];
     if (settings) {
-        updateSettings(settings, options.programPath);
+        updateSettings(settings, snoProgramPath(options.programPath));
         writes.unshift({
             path: join(options.configDir, "settings.json"),
             content: `${JSON.stringify(settings, null, 2)}\n`,

package/dist/messages.d.ts

@@ -2,6 +2,7 @@ export declare const MESSAGES: {
     readonly usage: "Run through sno: sno memory <recall|get|remember|correct|import|doctor> --harness claude, or sno memory hook <event> --harness claude";
     readonly dryRunPrefix: "would write";
     readonly installComplete: "Sno memory for Claude Code installed";
+    readonly uninstallComplete: "Sno memory for Claude Code removed";
     readonly settingsUnparsable: "settings.json parse error; settings preserved";
     readonly importCaptureDisabled: "Automatic capture is off in settings.json (capture.ambient); imported notes will be skipped.";
     readonly doctorUnavailable: "doctor: unavailable";

package/dist/messages.js

@@ -2,6 +2,7 @@ export const MESSAGES = {
     usage: "Run through sno: sno memory <recall|get|remember|correct|import|doctor> --harness claude, or sno memory hook <event> --harness claude",
     dryRunPrefix: "would write",
     installComplete: "Sno memory for Claude Code installed",
+    uninstallComplete: "Sno memory for Claude Code removed",
     settingsUnparsable: "settings.json parse error; settings preserved",
     importCaptureDisabled: "Automatic capture is off in settings.json (capture.ambient); imported notes will be skipped.",
     doctorUnavailable: "doctor: unavailable",

package/dist/worker.js

@@ -5,7 +5,7 @@ import { createServer } from "node:http";
 import { userInfo } from "node:os";
 import { readFile, readdir, unlink } from "node:fs/promises";
 import { join } from "node:path";
-import { CODING_SKIN_CHILD_DEADLINE_MS, CODING_SKIN_CHILD_MAX_BUFFER_BYTES, CODING_SKIN_IMPORT_INTERVAL_MS, CODING_SKIN_MAX_ATTEMPTS, CODING_SKIN_RETRY_DELAYS_MS, CODING_SKIN_WORKER_LIFETIME_MS, HOST_MODEL_CALLBACK_HOST, HOST_MODEL_CALLBACK_PATH, } from "@snoai/memory/coding-skin";
+import { CODING_SKIN_CHILD_DEADLINE_MS, CODING_SKIN_CHILD_MAX_BUFFER_BYTES, CODING_SKIN_IMPORT_INTERVAL_MS, CODING_SKIN_MAX_ATTEMPTS, CODING_SKIN_RETRY_DELAYS_MS, CODING_SKIN_WORKER_LIFETIME_MS, HOST_MODEL_CALLBACK_HOST, HOST_MODEL_CALLBACK_PATH, HOST_MODEL_DEADLINE_HEADER, } from "@snoai/memory/coding-skin";
 import { z } from "zod";
 import { MODEL_ID, SKIN_ID } from "./constants.js";
 import { acquirePidFileLock, writeJsonAtomic } from "./files.js";
@@ -133,6 +133,14 @@ async function callbackServer(credential, activeCwd, isImport, onCall, runChild)
                 return;
             }
             onCall();
+            // Calls run one at a time and a child blocks the event loop, so a requester may have stopped waiting before
+            // this call's turn: skip it instead of spending a model run on an answer nobody reads.
+            const deadline = Number(request.headers[HOST_MODEL_DEADLINE_HEADER]);
+            if (Number.isFinite(deadline) && deadline <= Date.now()) {
+                console.log(JSON.stringify({ event: "model-callback-expired", model: requestBody.model }));
+                response.writeHead(504).end(JSON.stringify({ error: { kind: "cancelled", reason: "deadline" } }));
+                return;
+            }
             if (isImport() && lastImportChildAt > 0) {
                 const remaining = CODING_SKIN_IMPORT_INTERVAL_MS - (Date.now() - lastImportChildAt);
                 if (remaining > 0)
@@ -142,7 +150,7 @@ async function callbackServer(credential, activeCwd, isImport, onCall, runChild)
                 lastImportChildAt = Date.now();
                 console.log(JSON.stringify({ event: "import-child-start", at: lastImportChildAt }));
             }
-            const result = await runChild(requestBody.prompt, cwd);
+            const result = await runChild(requestBody.prompt, cwd, Number.isFinite(deadline) ? deadline - Date.now() : undefined);
             const status = result.kind === "ok" ? 200 : result.kind === "cancelled" ? 504 : 503;
             console.log(JSON.stringify({ event: "model-callback", model: requestBody.model, status }));
             response.setHeader("content-type", "application/json");
@@ -208,7 +216,7 @@ export async function runWorker(dependencies = productionDependencies()) {
     let handoff = false;
     try {
         mkdirSync(childCwd, { recursive: true, mode: 0o700 });
-        const callback = await callbackServer(credential, () => currentCwd ?? childCwd, () => currentImport, () => { lastCallbackAt = now(); }, (prompt, cwd) => dependencies.runChild(prompt, cwd, Math.min(CODING_SKIN_CHILD_DEADLINE_MS, CODING_SKIN_WORKER_LIFETIME_MS - (now() - workerStartedAt))));
+        const callback = await callbackServer(credential, () => currentCwd ?? childCwd, () => currentImport, () => { lastCallbackAt = now(); }, (prompt, cwd, requesterMs) => dependencies.runChild(prompt, cwd, Math.min(CODING_SKIN_CHILD_DEADLINE_MS, CODING_SKIN_WORKER_LIFETIME_MS - (now() - workerStartedAt), requesterMs ?? Infinity)));
         server = callback.server;
         const client = await dependencies.connect();
         const principal = client.principal || userInfo().username;
@@ -263,9 +271,11 @@ export async function runWorker(dependencies = productionDependencies()) {
                         await unlink(path);
                         break;
                     }
-                    catch {
+                    catch (error) {
                         await updateImportReceipt(record.importReceipt, "failures");
                         const attempts = record.attempts + 1;
+                        console.log(JSON.stringify({ event: "capture-failed", turnId: record.turnId, attempt: attempts,
+                            final: attempts >= CODING_SKIN_MAX_ATTEMPTS, error: error instanceof Error ? error.message : String(error) }));
                         const retryDelay = CODING_SKIN_RETRY_DELAYS_MS[attempts - 1];
                         record = {
                             ...record,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@snoai/mem-claude",
-  "version": "1.2.4",
+  "version": "1.2.6",
   "license": "Apache-2.0",
   "publishConfig": { "access": "public" },
   "repository": {
@@ -26,11 +26,10 @@
   },
   "dependencies": {
     "@snoai/memory": "^1.2.0",
-    "fs-ext": "^2.1.1",
+    "fs-native-extensions": "^1.5.1",
     "zod": "^4.5.4"
   },
   "devDependencies": {
-    "@types/fs-ext": "^2.0.3",
     "@types/node": "^22.19.17",
     "typescript": "^7.0.2"
   }