ccdesk 0.1.0 → 0.2.0

package/dist/server/watch.js

@@ -1,9 +1,11 @@
 import { watch } from "node:fs";
+import { stat } from "node:fs/promises";
 import { basename, dirname, join } from "node:path";
+import { storeDirName } from "../shared/memory.js";
 import {} from "../shared/types.js";
 import {} from "./scan/env.js";
 import { isNetworkPath, mainWorktreeRoot } from "./scan/files.js";
-import { storeDirName } from "./scan/memory.js";
+import { scanDirectory } from "./scan/index.js";
 /** How long one request waits for a change before answering "nothing changed". */
 const WAIT_MS = 25_000;
 /** Editors write a file in several steps; one change covers them all. */
@@ -71,18 +73,53 @@ export function dependencies(view) {
 /** One set of file watchers per directory a page is looking at, shared by its requests. */
 export class Watcher {
     env;
+    scanOf;
     subscriptions = new Map();
-    constructor(env) {
+    /** What the latest scan of each directory read, kept for a watch that starts after the scan. */
+    scanned = new Map();
+    latest = new Map();
+    constructor(env, scanOf = scanDirectory) {
         this.env = env;
+        this.scanOf = scanOf;
     }
-    /** Remembers what the latest scan of `dir` read, so those files are watched too. */
-    track(dir, view) {
-        const subscription = this.subscriptions.get(dir);
+    /** Scans `dir` and remembers what the scan read, so those files are watched too. */
+    async scan(dir, profile = "interactive") {
+        const startedAt = Date.now();
+        const stateFile = await this.stateFile();
+        const view = await this.scanOf(this.env, dir, profile);
+        const subscription = this.subscriptions.get(view.path);
+        // Only a watched directory's view can be known to be current later.
+        if (subscription)
+            this.latest.set(view.path, { view, startedAt, stateFile });
         const extra = dependencies(view);
-        if (!subscription || JSON.stringify(extra) === JSON.stringify(subscription.extra))
-            return;
-        subscription.extra = extra;
-        void this.rewatch(dir, subscription);
+        this.scanned.set(view.path, extra);
+        if (subscription && JSON.stringify(extra) !== JSON.stringify(subscription.extra)) {
+            subscription.extra = extra;
+            void this.rewatch(view.path, subscription);
+        }
+        return view;
+    }
+    /**
+     * The view of `dir`: the latest scan while it is known to be current, else a new scan. It is
+     * current only while watchers that started before it have seen no change since it started, and
+     * ~/.claude.json, which is not watched, is as it was. Only an interactive scan is reused, as the
+     * path tester describes an interactive session.
+     */
+    async view(dir) {
+        const latest = this.latest.get(dir);
+        const subscription = this.subscriptions.get(dir);
+        if (latest?.view.profile === "interactive" &&
+            subscription &&
+            subscription.watchingSince < latest.startedAt &&
+            subscription.touchedAt < latest.startedAt &&
+            latest.stateFile === (await this.stateFile()))
+            return latest.view;
+        return this.scan(dir);
+    }
+    /** ~/.claude.json's size and time; Claude Code rewrites it too often to watch. */
+    async stateFile() {
+        const info = await stat(this.env.claudeJson).catch(() => null);
+        return info ? `${info.size}:${info.mtimeMs}` : "missing";
     }
     /**
      * Answers once something changed after `since` (ms since the epoch), or after `timeoutMs` with
@@ -122,8 +159,10 @@ export class Watcher {
         const subscription = {
             watchers: [],
             changedAt: 0,
+            touchedAt: 0,
+            watchingSince: Number.POSITIVE_INFINITY,
             waiters: new Set(),
-            extra: [],
+            extra: this.scanned.get(dir) ?? [],
         };
         this.subscriptions.set(dir, subscription);
         await this.rewatch(dir, subscription);
@@ -138,6 +177,7 @@ export class Watcher {
         for (const w of subscription.watchers)
             w.close();
         this.subscriptions.delete(dir);
+        this.latest.delete(dir);
     }
     /** (Re)creates the watchers, so a folder created since, such as a new .claude, is watched. */
     async rewatch(dir, subscription) {
@@ -153,6 +193,7 @@ export class Watcher {
                     const changed = name === null ? "" : String(name);
                     if (target.names && !target.names.includes(basename(changed)))
                         return;
+                    subscription.touchedAt = Date.now();
                     clearTimeout(subscription.settle);
                     subscription.settle = setTimeout(() => {
                         subscription.changedAt = Date.now();
@@ -168,5 +209,6 @@ export class Watcher {
                 // A folder that does not exist yet is caught by watching its parent.
             }
         }
+        subscription.watchingSince = Date.now();
     }
 }

package/dist/server/write.js

@@ -3,7 +3,7 @@ import { chmod, link, lstat, mkdir, open, readFile, realpath, rename, rm, writeF
 import { basename, dirname, join } from "node:path";
 import {} from "../shared/types.js";
 import {} from "./scan/env.js";
-import { isSecretPath, leadsToSecret, revisionOf } from "./scan/files.js";
+import { isCredentials, isSecretPath, revisionOf } from "./scan/files.js";
 /** A change ccdesk refuses on purpose; the server answers 409 with the message. */
 export class RefusedError extends Error {
 }
@@ -29,16 +29,6 @@ export function backupRoot(env) {
 function realOrNull(path) {
     return realpath(path).catch(() => null);
 }
-/**
- * Whether a path is Claude Code's credentials file: by name, through any link on the way, or by
- * ending at the same file as `<config>/.credentials.json`, so one kept under another name counts.
- */
-export async function isCredentials(env, path) {
-    if (await leadsToSecret(path))
-        return true;
-    const real = await realOrNull(path);
-    return real !== null && real === (await realOrNull(join(env.claudeDir, ".credentials.json")));
-}
 /** The file a path leads to after links; a missing file keeps its own path. */
 async function target(env, path) {
     if (await isCredentials(env, path))
@@ -75,7 +65,8 @@ export async function readIfExists(env, path) {
  * written to a temporary file first and the revision is checked again just before the rename, so
  * an edit made elsewhere while ccdesk was saving is kept and the save refused. A symlink is written
  * through, so links into a dotfiles repository survive; the temporary file is new, unguessable and
- * created exclusively, so nothing planted beside the target can redirect the write.
+ * created exclusively, so nothing planted beside the target can redirect the write. A file with
+ * other hard links is refused, since the rename would leave them on the old text.
  */
 export async function writeAtomic(env, path, content, expected) {
     const file = await target(env, path);
@@ -83,6 +74,8 @@ export async function writeAtomic(env, path, content, expected) {
         throw new RefusedError(STATE_FILE);
     await mkdir(dirname(file), { recursive: true });
     const existing = await lstat(file).catch(() => null);
+    if (existing && existing.nlink > 1)
+        throw new RefusedError(`${path} has other hard links, and saving it would split it from its other names; edit it in your editor.`);
     const temp = join(dirname(file), `.${basename(file)}.ccdesk-${randomBytes(6).toString("hex")}`);
     const handle = await open(temp, "wx", 0o600);
     try {
@@ -111,7 +104,15 @@ export async function writeAtomic(env, path, content, expected) {
 export async function removeExactly(path, expected) {
     const aside = join(dirname(path), `.${basename(path)}.ccdesk-${randomBytes(6).toString("hex")}`);
     await rename(path, aside);
-    if (revisionOf(await readFile(aside, "utf8")) === expected) {
+    let text;
+    try {
+        text = await readFile(aside, "utf8");
+    }
+    catch (error) {
+        await rename(aside, path);
+        throw error;
+    }
+    if (revisionOf(text) === expected) {
         await rm(aside);
         return true;
     }
@@ -132,8 +133,50 @@ export async function removeExactly(path, expected) {
     return false;
 }
 export const MANIFEST = "ccdesk-backup.json";
+/** Takes a change out of Recent changes, for one whose effect was undone again right away. */
+export function forgetChange(env, id) {
+    return rm(join(backupRoot(env), id), { recursive: true, force: true });
+}
 /** The copy of the target inside a backup folder. */
 export const SNAPSHOT = "before";
+/** For a change made through `claude mcp`: the affected servers after it, values hidden. */
+export const SHOWN_AFTER = "after";
+/** A new, empty backup folder that only you can read, and its id. */
+async function newBackup(env, kind) {
+    const createdAt = new Date().toISOString();
+    const id = `${createdAt.replace(/[:.]/g, "-")}-${randomBytes(3).toString("hex")}-${kind}`;
+    const root = backupRoot(env);
+    const dir = join(root, id);
+    await mkdir(dir, { recursive: true, mode: 0o700 });
+    await chmod(root, 0o700);
+    return { createdAt, id, dir };
+}
+/**
+ * Lists a change Claude Code made through `claude mcp` in Recent changes. ccdesk cannot undo it,
+ * so it keeps only the affected servers before and after as the page shows them, secrets hidden,
+ * and the commands that would put them back; never a value the page does not show.
+ */
+export async function recordClaudeMcpChange(env, record) {
+    const { createdAt, dir } = await newBackup(env, "mcp-claude");
+    const manifest = {
+        kind: "mcp-claude",
+        target: record.target,
+        createdAt,
+        before: revisionOf(record.shownBefore),
+        after: revisionOf(record.shownAfter),
+        undoCommands: record.undoCommands,
+    };
+    try {
+        await writeFile(join(dir, SNAPSHOT), record.shownBefore, { mode: 0o600 });
+        await writeFile(join(dir, SHOWN_AFTER), record.shownAfter, { mode: 0o600 });
+        // Written last, so a folder without it is never listed.
+        await writeFile(join(dir, MANIFEST), `${JSON.stringify(manifest, null, 2)}\n`, { mode: 0o600 });
+    }
+    catch (error) {
+        await rm(dir, { recursive: true, force: true });
+        throw error;
+    }
+}
 /**
  * Makes a change and records it in Recent changes. The file's previous text and a manifest are put
  * in a new backup folder first, so a change interrupted halfway can still be restored; the manifest
@@ -142,12 +185,7 @@ export const SNAPSHOT = "before";
  * otherwise it stays, marked partial, so it can be put back. Backups can hold settings with secrets, so only the user can read them.
  */
 export async function recordChange(env, record, change) {
-    const createdAt = new Date().toISOString();
-    const id = `${createdAt.replace(/[:.]/g, "-")}-${randomBytes(3).toString("hex")}-${record.kind}`;
-    const root = backupRoot(env);
-    const dir = join(root, id);
-    await mkdir(dir, { recursive: true, mode: 0o700 });
-    await chmod(root, 0o700);
+    const { createdAt, id, dir } = await newBackup(env, record.kind);
     const manifest = {
         kind: record.kind,
         target: record.target,
@@ -191,5 +229,5 @@ export async function recordChange(env, record, change) {
     }
     manifest.after = result.revision;
     await writeManifest();
-    return { ...result, id };
+    return { ...result, id, created: record.before === null };
 }

package/dist/shared/compare.js

@@ -0,0 +1 @@
+import {} from "./types.js";

package/dist/shared/hook-events.json

@@ -0,0 +1,35 @@
+[
+    "PreToolUse",
+    "PostToolUse",
+    "PostToolUseFailure",
+    "PostToolBatch",
+    "Notification",
+    "UserPromptSubmit",
+    "UserPromptExpansion",
+    "SessionStart",
+    "SessionEnd",
+    "Stop",
+    "StopFailure",
+    "SubagentStart",
+    "SubagentStop",
+    "PreCompact",
+    "PostCompact",
+    "PreModelSwitch",
+    "PostModelSwitch",
+    "PermissionRequest",
+    "PermissionDenied",
+    "Setup",
+    "TeammateIdle",
+    "TaskCreated",
+    "TaskCompleted",
+    "Elicitation",
+    "ElicitationResult",
+    "ConfigChange",
+    "WorktreeCreate",
+    "WorktreeRemove",
+    "InstructionsLoaded",
+    "CwdChanged",
+    "FileChanged",
+    "DirectoryAdded",
+    "MessageDisplay"
+]

package/dist/shared/mcp-server.schema.json

@@ -0,0 +1,25 @@
+{
+    "$schema": "http://json-schema.org/draft-07/schema#",
+    "$comment": "One server entry of .mcp.json, ~/.claude.json or claude mcp add-json, with the fields https://code.claude.com/docs/en/mcp defines. Fields it does not name are left alone.",
+    "type": "object",
+    "properties": {
+        "type": { "enum": ["stdio", "http", "streamable-http", "sse", "ws"] },
+        "command": { "type": "string" },
+        "args": { "type": "array", "items": { "type": "string" } },
+        "env": { "type": "object", "additionalProperties": { "type": "string" } },
+        "url": { "type": "string" },
+        "headers": { "type": "object", "additionalProperties": { "type": "string" } },
+        "headersHelper": { "type": "string" },
+        "oauth": {
+            "type": "object",
+            "properties": {
+                "clientId": { "type": "string" },
+                "callbackPort": { "type": "integer" },
+                "authServerMetadataUrl": { "type": "string" },
+                "scopes": { "type": "string" }
+            }
+        },
+        "timeout": { "type": "number" },
+        "alwaysLoad": { "type": "boolean" }
+    }
+}

package/dist/shared/memory.js

@@ -0,0 +1,4 @@
+/** Claude Code names a project's store after its path with every non-alphanumeric character as "-". */
+export function storeDirName(projectPath) {
+    return projectPath.replace(/[^a-zA-Z0-9]/g, "-");
+}

package/dist/shared/scopes.js

@@ -1,10 +1,12 @@
 import scopeTable from "./settings-scopes.json" with { type: "json" };
 import {} from "./types.js";
-const EVERY_FILE = ["user", "project", "local", "managed"];
+export const EVERY_FILE = ["user", "project", "local", "managed"];
 /** Settings files by precedence: managed beats local beats project beats user. */
 export const HIGHEST_FIRST = ["managed", "local", "project", "user"];
 /** The settings files ccdesk writes to; managed settings belong to your organisation. */
 export const EDITABLE_SCOPES = ["user", "project", "local"];
+/** The permission lists, in the order ccdesk shows them. */
+export const PERMISSION_LISTS = ["allow", "ask", "deny"];
 /** Keys Claude Code reads only from some files, from the settings index (`pnpm scopes`). */
 const SCOPE_LIMITED_KEYS = scopeTable.limited;
 export function allowedScopes(key) {

package/dist/shared/types.js

@@ -1,2 +1,2 @@
 // Shapes the server sends to the UI. Paths are absolute; the UI shortens them for display.
-export {};
+export const SESSION_PROFILES = ["interactive", "print"];