harnery 0.41.0 → 0.42.0

package/dist/lib/claude-desktop-share.js

@@ -0,0 +1,394 @@
+import { spawn, spawnSync } from "node:child_process";
+import { closeSync, copyFileSync, cpSync, existsSync, mkdirSync, openSync, readdirSync, readFileSync, readSync, renameSync, rmSync, statSync, writeFileSync, } from "node:fs";
+import { homedir } from "node:os";
+import { dirname, join } from "node:path";
+import { listAccounts } from "./claude-desktop.js";
+/** macOS st_flags bit for a file whose contents live only in the cloud. */
+const SF_DATALESS = 0x40000000;
+/**
+ * Paths whose bytes are not on this disk yet. On macOS this reads st_flags
+ * (Node's stat does not expose them) in one `stat` call; everywhere else only
+ * the `.<name>.icloud` stub convention applies.
+ */
+export function findPlaceholders(paths) {
+    const out = new Set();
+    const present = [];
+    for (const p of paths) {
+        if (existsSync(p))
+            present.push(p);
+        else if (existsSync(join(dirname(p), `.${p.slice(dirname(p).length + 1)}.icloud`)))
+            out.add(p);
+    }
+    if (process.platform !== "darwin" || present.length === 0)
+        return out;
+    const r = spawnSync("/usr/bin/stat", ["-f", "%Xf %N", ...present], { encoding: "utf8" });
+    for (const line of (r.stdout ?? "").split("\n")) {
+        const sp = line.indexOf(" ");
+        if (sp < 0)
+            continue;
+        const flags = Number.parseInt(line.slice(0, sp), 16);
+        if (Number.isFinite(flags) && (flags & SF_DATALESS) !== 0)
+            out.add(line.slice(sp + 1));
+    }
+    return out;
+}
+/** Best-effort, fire-and-forget: ask iCloud Drive to fetch these paths. */
+export function requestDownload(paths) {
+    if (process.platform !== "darwin")
+        return;
+    for (const p of paths) {
+        try {
+            spawn("/usr/bin/brctl", ["download", p], { stdio: "ignore", detached: true }).unref();
+        }
+        catch {
+            // Not an iCloud folder or brctl missing; the next pass retries.
+        }
+    }
+}
+export function defaultShareDir(home = homedir()) {
+    if (process.platform !== "darwin")
+        return null;
+    const icloud = join(home, "Library", "Mobile Documents", "com~apple~CloudDocs");
+    return existsSync(icloud) ? join(icloud, "Harnery", "claude-sessions") : null;
+}
+/** Claude Code's per-project transcript folder name for a working directory. */
+export function projectSlug(cwd) {
+    return cwd.replace(/[^a-zA-Z0-9]/g, "-");
+}
+function transcriptPath(home, cwd, cliSessionId) {
+    return join(home, ".claude", "projects", projectSlug(cwd), `${cliSessionId}.jsonl`);
+}
+function safeStat(p) {
+    try {
+        return statSync(p);
+    }
+    catch {
+        return null;
+    }
+}
+function safeReaddir(dir) {
+    try {
+        return readdirSync(dir);
+    }
+    catch {
+        return [];
+    }
+}
+function readJson(p) {
+    try {
+        const v = JSON.parse(readFileSync(p, "utf8"));
+        return typeof v === "object" && v !== null ? v : null;
+    }
+    catch {
+        return null;
+    }
+}
+/** Rewrite a path from the remote home to the local one (same layout, different user). */
+export function remapHome(p, remoteHome, localHome) {
+    if (!remoteHome || remoteHome === localHome)
+        return p;
+    if (p === remoteHome)
+        return localHome;
+    return p.startsWith(`${remoteHome}/`) ? localHome + p.slice(remoteHome.length) : p;
+}
+/** True when `prefixFile`'s bytes are exactly the start of `fullFile`. */
+export function isBytePrefix(prefixFile, fullFile) {
+    const a = safeStat(prefixFile);
+    const b = safeStat(fullFile);
+    if (!a || !b || a.size > b.size)
+        return false;
+    const chunk = 1 << 20;
+    const fa = openSync(prefixFile, "r");
+    const fb = openSync(fullFile, "r");
+    try {
+        const ba = Buffer.alloc(chunk);
+        const bb = Buffer.alloc(chunk);
+        let pos = 0;
+        while (pos < a.size) {
+            const n = Math.min(chunk, a.size - pos);
+            readSync(fa, ba, 0, n, pos);
+            readSync(fb, bb, 0, n, pos);
+            if (ba.compare(bb, 0, n, 0, n) !== 0)
+                return false;
+            pos += n;
+        }
+        return true;
+    }
+    finally {
+        closeSync(fa);
+        closeSync(fb);
+    }
+}
+/** Newest non-archived entry per cliSessionId across every local account. */
+function localEntriesById(accounts) {
+    const out = new Map();
+    for (const a of accounts) {
+        for (const e of a.entries) {
+            if (!e.cliSessionId)
+                continue;
+            const prev = out.get(e.cliSessionId);
+            if (!prev || (e.lastActivityAt ?? 0) > (prev.lastActivityAt ?? 0))
+                out.set(e.cliSessionId, e);
+        }
+    }
+    return out;
+}
+/**
+ * Env directory new entries go into: the one holding the account's newest
+ * entry, else any env directory the app already created for the account.
+ */
+function targetEnvDir(account) {
+    if (!account)
+        return null;
+    const newest = account.entries[0];
+    if (newest)
+        return join(account.path, newest.envId);
+    const env = safeReaddir(account.path).find((d) => safeStat(join(account.path, d))?.isDirectory());
+    return env ? join(account.path, env) : null;
+}
+export function planShare(opts) {
+    const home = opts.home ?? homedir();
+    const now = opts.now ?? Date.now();
+    const liveWindow = opts.liveWindowMs ?? 3 * 60_000;
+    const cutoff = now - opts.days * 86_400_000;
+    const accounts = listAccounts(opts.dataDir);
+    const local = localEntriesById(accounts);
+    // Export: this machine's recent sessions whose transcript exists here and
+    // differs from what was last published.
+    const exports = [];
+    const mine = join(opts.shareDir, opts.machine, "sessions");
+    for (const e of local.values()) {
+        if (e.isArchived || !e.cwd || !e.cliSessionId)
+            continue;
+        if ((e.lastActivityAt ?? 0) < cutoff)
+            continue;
+        const t = transcriptPath(home, e.cwd, e.cliSessionId);
+        const st = safeStat(t);
+        if (!st)
+            continue;
+        const published = safeStat(join(mine, e.cliSessionId, "transcript.jsonl"));
+        const publishedEntry = readJson(join(mine, e.cliSessionId, "entry.json"));
+        const entryCurrent = publishedEntry?.lastActivityAt === e.lastActivityAt && publishedEntry?.title === e.title;
+        if (published && published.size === st.size && entryCurrent)
+            continue;
+        exports.push({ cliSessionId: e.cliSessionId, title: e.title, transcript: t, bytes: st.size });
+    }
+    // Import: every other machine's published sessions.
+    const imports = [];
+    const skips = [];
+    const machines = [];
+    const target = accounts.find((a) => a.accountUuid === opts.targetAccountUuid);
+    const envDir = targetEnvDir(target) ??
+        join(opts.dataDir, "claude-code-sessions", opts.targetAccountUuid, "shared");
+    for (const machine of safeReaddir(opts.shareDir)) {
+        if (machine === opts.machine)
+            continue;
+        const mdir = join(opts.shareDir, machine);
+        const manifest = readJson(join(mdir, "manifest.json"));
+        if (!manifest)
+            continue;
+        machines.push(machine);
+        const remoteHome = typeof manifest.home === "string" ? manifest.home : null;
+        const ids = safeReaddir(join(mdir, "sessions")).filter((id) => !id.startsWith("."));
+        const files = ids.flatMap((id) => [
+            join(mdir, "sessions", id, "entry.json"),
+            join(mdir, "sessions", id, "transcript.jsonl"),
+        ]);
+        const placeholders = (opts.findPlaceholders ?? findPlaceholders)(files);
+        const toDownload = [];
+        for (const id of ids) {
+            const sdir = join(mdir, "sessions", id);
+            const entryFrom = join(sdir, "entry.json");
+            if (placeholders.has(entryFrom) || placeholders.has(join(sdir, "transcript.jsonl"))) {
+                toDownload.push(sdir);
+                skips.push({ machine, cliSessionId: id, title: null, reason: "not-downloaded" });
+                continue;
+            }
+            const remote = readJson(entryFrom);
+            const remoteTranscript = join(sdir, "transcript.jsonl");
+            const title = typeof remote?.title === "string" ? remote.title : null;
+            if (!remote || typeof remote.cwd !== "string" || !safeStat(remoteTranscript)) {
+                skips.push({ machine, cliSessionId: id, title, reason: "unreadable" });
+                continue;
+            }
+            const remoteLast = typeof remote.lastActivityAt === "number" ? remote.lastActivityAt : null;
+            if (remote.isArchived === true || (remoteLast ?? 0) < cutoff)
+                continue;
+            const cwd = remapHome(remote.cwd, remoteHome, home);
+            if (!existsSync(cwd)) {
+                skips.push({ machine, cliSessionId: id, title, reason: "missing-cwd" });
+                continue;
+            }
+            const existing = local.get(id);
+            const transcriptTo = transcriptPath(home, cwd, id);
+            const localSt = safeStat(transcriptTo);
+            const remoteSt = safeStat(remoteTranscript);
+            let copyTranscript = false;
+            if (!localSt) {
+                copyTranscript = true;
+            }
+            else if (remoteSt && remoteSt.size > localSt.size) {
+                if (now - localSt.mtimeMs < liveWindow) {
+                    skips.push({ machine, cliSessionId: id, title, reason: "live-here" });
+                    continue;
+                }
+                if (!isBytePrefix(transcriptTo, remoteTranscript)) {
+                    skips.push({ machine, cliSessionId: id, title, reason: "diverged" });
+                    continue;
+                }
+                copyTranscript = true;
+            }
+            else if (remoteSt && remoteSt.size < localSt.size && existing) {
+                // Continued here since the other machine last saw it; keep ours.
+                skips.push({ machine, cliSessionId: id, title, reason: "local-newer" });
+                continue;
+            }
+            const entryStale = !existing ||
+                (copyTranscript && (remoteLast ?? 0) > (existing.lastActivityAt ?? 0)) ||
+                (copyTranscript && title !== existing.title);
+            if (!copyTranscript && !entryStale) {
+                skips.push({ machine, cliSessionId: id, title, reason: "up-to-date" });
+                continue;
+            }
+            const sidecar = join(sdir, "sidecar");
+            imports.push({
+                kind: !existing ? (copyTranscript ? "new" : "entry-only") : "updated",
+                machine,
+                cliSessionId: id,
+                title,
+                cwd,
+                transcriptFrom: copyTranscript ? remoteTranscript : null,
+                transcriptTo,
+                sidecarFrom: copyTranscript && existsSync(sidecar) ? sidecar : null,
+                entryFrom,
+                entryTo: existing
+                    ? existing.file
+                    : join(envDir, `${typeof remote.sessionId === "string" ? remote.sessionId : `local_${id}`}.json`),
+                entryExists: Boolean(existing),
+                remoteLastActivityAt: remoteLast,
+            });
+        }
+        if (toDownload.length > 0)
+            (opts.requestDownload ?? requestDownload)(toDownload);
+    }
+    return { exports, imports, skips, machines };
+}
+/** Write via a temp file + rename so a syncing reader never sees half a file. */
+function atomicCopy(from, to) {
+    mkdirSync(dirname(to), { recursive: true });
+    const tmp = `${to}.harnery-tmp`;
+    try {
+        copyFileSync(from, tmp);
+        renameSync(tmp, to);
+    }
+    catch (err) {
+        rmSync(tmp, { force: true });
+        throw err;
+    }
+}
+function atomicWrite(to, content) {
+    mkdirSync(dirname(to), { recursive: true });
+    const tmp = `${to}.harnery-tmp`;
+    writeFileSync(tmp, content);
+    renameSync(tmp, to);
+}
+export function applyShare(plan, opts) {
+    const home = opts.home ?? homedir();
+    const mdir = join(opts.shareDir, opts.machine);
+    const accounts = listAccounts(opts.dataDir);
+    const local = localEntriesById(accounts);
+    for (const x of plan.exports) {
+        const e = local.get(x.cliSessionId);
+        if (!e)
+            continue;
+        const sdir = join(mdir, "sessions", x.cliSessionId);
+        atomicCopy(x.transcript, join(sdir, "transcript.jsonl"));
+        const sidecar = join(dirname(x.transcript), x.cliSessionId);
+        if (existsSync(sidecar))
+            cpSync(sidecar, join(sdir, "sidecar"), { recursive: true, force: true });
+        atomicCopy(e.file, join(sdir, "entry.json"));
+    }
+    atomicWrite(join(mdir, "manifest.json"), `${JSON.stringify({ machine: opts.machine, home, exported_at: new Date(opts.now ?? Date.now()).toISOString() }, null, 2)}\n`);
+    let imported = 0;
+    const failed = [];
+    for (const x of plan.imports) {
+        try {
+            if (importOne(x, opts, home))
+                imported++;
+        }
+        catch (err) {
+            failed.push({
+                machine: x.machine,
+                cliSessionId: x.cliSessionId,
+                title: x.title,
+                error: err instanceof Error ? err.message : String(err),
+            });
+        }
+    }
+    return { exported: plan.exports.length, imported, failed };
+}
+function importOne(x, opts, home) {
+    const remote = readJson(x.entryFrom);
+    if (!remote)
+        return false;
+    const remoteManifest = readJson(join(opts.shareDir, x.machine, "manifest.json"));
+    const remoteHome = typeof remoteManifest?.home === "string" ? remoteManifest.home : null;
+    if (x.transcriptFrom)
+        atomicCopy(x.transcriptFrom, x.transcriptTo);
+    if (x.sidecarFrom) {
+        cpSync(x.sidecarFrom, join(dirname(x.transcriptTo), x.cliSessionId), {
+            recursive: true,
+            force: true,
+        });
+    }
+    let entry;
+    if (x.entryExists) {
+        entry = readJson(x.entryTo) ?? {};
+        if (typeof remote.title === "string")
+            entry.title = remote.title;
+        if (typeof remote.lastActivityAt === "number")
+            entry.lastActivityAt = remote.lastActivityAt;
+    }
+    else {
+        entry = { ...remote, isArchived: false };
+        for (const k of ["cwd", "originCwd"]) {
+            if (typeof entry[k] === "string")
+                entry[k] = remapHome(entry[k], remoteHome, home);
+        }
+        if (Array.isArray(entry.gitAnchors)) {
+            entry.gitAnchors = entry.gitAnchors.map((g) => ({
+                ...g,
+                gitRoot: typeof g.gitRoot === "string" ? remapHome(g.gitRoot, remoteHome, home) : g.gitRoot,
+                commonDir: typeof g.commonDir === "string" ? remapHome(g.commonDir, remoteHome, home) : g.commonDir,
+            }));
+        }
+    }
+    atomicWrite(x.entryTo, `${JSON.stringify(entry)}\n`);
+    return true;
+}
+export function shareSummary(plan) {
+    return {
+        machines: plan.machines,
+        export: plan.exports.map((x) => ({
+            title: x.title,
+            cli_session_id: x.cliSessionId,
+            bytes: x.bytes,
+        })),
+        import: plan.imports.map((x) => ({
+            kind: x.kind,
+            from_machine: x.machine,
+            title: x.title,
+            cli_session_id: x.cliSessionId,
+        })),
+        skipped: plan.skips
+            .filter((s) => s.reason !== "up-to-date" && s.reason !== "not-downloaded")
+            .map((s) => ({
+            from_machine: s.machine,
+            title: s.title,
+            cli_session_id: s.cliSessionId,
+            reason: s.reason,
+        })),
+        not_downloaded: plan.skips.filter((s) => s.reason === "not-downloaded").length,
+        up_to_date: plan.skips.filter((s) => s.reason === "up-to-date").length,
+    };
+}

package/dist/lib/disk-usage.d.ts

@@ -0,0 +1,50 @@
+export declare const DISK_GIT_STATES: readonly ["tracked", "untracked", "ignored", "git-metadata", "non-repository", "unknown"];
+export type DiskGitState = (typeof DISK_GIT_STATES)[number];
+export type DiskGroup = "directory" | "repository" | "extension" | "git" | "files";
+export interface DiskOptions {
+    git?: string;
+    type?: string;
+    exclude?: string[];
+    group?: DiskGroup;
+    depth?: number;
+    top?: number;
+    minSize?: number;
+    apparent?: boolean;
+}
+export interface DiskTotals {
+    files: number;
+    apparent_bytes: number;
+    allocated_bytes: number | null;
+}
+export interface DiskRow extends DiskTotals {
+    path: string;
+}
+export interface DiskReport {
+    schema: "harnery.disk-usage/v1";
+    root: string;
+    measurement: "allocated" | "apparent" | "apparent-fallback";
+    complete: boolean;
+    filters: DiskOptions;
+    totals: DiskTotals;
+    git: Record<DiskGitState, DiskTotals>;
+    groups: DiskRow[];
+    group_count: number;
+    largest_files: (DiskRow & {
+        git: DiskGitState;
+        repository: string | null;
+    })[];
+    repositories: string[];
+    skipped: {
+        symlinks: number;
+        special_files: number;
+        excluded: number;
+    };
+    issues: {
+        path: string;
+        message: string;
+    }[];
+}
+export declare function parseDiskSize(value: string): number;
+/** Inspect regular files only. No bodies are read and no symlinks are followed. */
+export declare function diskUsage(input?: string, options?: DiskOptions): DiskReport;
+//# sourceMappingURL=disk-usage.d.ts.map

package/dist/lib/disk-usage.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"disk-usage.d.ts","sourceRoot":"","sources":["../../src/lib/disk-usage.ts"],"names":[],"mappings":"AAIA,eAAO,MAAM,eAAe,2FAOlB,CAAC;AACX,MAAM,MAAM,YAAY,GAAG,CAAC,OAAO,eAAe,CAAC,CAAC,MAAM,CAAC,CAAC;AAC5D,MAAM,MAAM,SAAS,GAAG,WAAW,GAAG,YAAY,GAAG,WAAW,GAAG,KAAK,GAAG,OAAO,CAAC;AAEnF,MAAM,WAAW,WAAW;IAC1B,GAAG,CAAC,EAAE,MAAM,CAAC;IACb,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,OAAO,CAAC,EAAE,MAAM,EAAE,CAAC;IACnB,KAAK,CAAC,EAAE,SAAS,CAAC;IAClB,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,GAAG,CAAC,EAAE,MAAM,CAAC;IACb,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,QAAQ,CAAC,EAAE,OAAO,CAAC;CACpB;AAED,MAAM,WAAW,UAAU;IACzB,KAAK,EAAE,MAAM,CAAC;IACd,cAAc,EAAE,MAAM,CAAC;IACvB,eAAe,EAAE,MAAM,GAAG,IAAI,CAAC;CAChC;AACD,MAAM,WAAW,OAAQ,SAAQ,UAAU;IACzC,IAAI,EAAE,MAAM,CAAC;CACd;AACD,MAAM,WAAW,UAAU;IACzB,MAAM,EAAE,uBAAuB,CAAC;IAChC,IAAI,EAAE,MAAM,CAAC;IACb,WAAW,EAAE,WAAW,GAAG,UAAU,GAAG,mBAAmB,CAAC;IAC5D,QAAQ,EAAE,OAAO,CAAC;IAClB,OAAO,EAAE,WAAW,CAAC;IACrB,MAAM,EAAE,UAAU,CAAC;IACnB,GAAG,EAAE,MAAM,CAAC,YAAY,EAAE,UAAU,CAAC,CAAC;IACtC,MAAM,EAAE,OAAO,EAAE,CAAC;IAClB,WAAW,EAAE,MAAM,CAAC;IACpB,aAAa,EAAE,CAAC,OAAO,GAAG;QAAE,GAAG,EAAE,YAAY,CAAC;QAAC,UAAU,EAAE,MAAM,GAAG,IAAI,CAAA;KAAE,CAAC,EAAE,CAAC;IAC9E,YAAY,EAAE,MAAM,EAAE,CAAC;IACvB,OAAO,EAAE;QAAE,QAAQ,EAAE,MAAM,CAAC;QAAC,aAAa,EAAE,MAAM,CAAC;QAAC,QAAQ,EAAE,MAAM,CAAA;KAAE,CAAC;IACvE,MAAM,EAAE;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,OAAO,EAAE,MAAM,CAAA;KAAE,EAAE,CAAC;CAC7C;AAoCD,wBAAgB,aAAa,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CAkBnD;AAED,mFAAmF;AACnF,wBAAgB,SAAS,CAAC,KAAK,SAAM,EAAE,OAAO,GAAE,WAAgB,GAAG,UAAU,CAiP5E"}