@gtc6244/immediacy-daemon 0.1.0

package/dist/src/protocol.js

@@ -0,0 +1,16 @@
+/**
+ * Wire protocol — the contract between the Mac daemon and the Flutter client.
+ *
+ * This file is the SOURCE OF TRUTH. The Dart mirror lives at
+ * app/lib/protocol.dart and must be kept in sync by hand (the shapes are small
+ * and stable enough that codegen is not worth the toolchain weight yet).
+ *
+ * Transport-agnostic by design: nothing here may assume Cloudflare, WSS, or any
+ * particular framing. A single multiplexed connection carries every message.
+ *
+ * The envelope fields (v, id, ts, ws, type) stay in clear for routing. Only
+ * `payload` is encrypted in the E2E layer (slice 5); until then it travels as
+ * plain JSON.
+ */
+export const PROTOCOL_VERSION = 1;
+//# sourceMappingURL=protocol.js.map

package/dist/src/protocol.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"protocol.js","sourceRoot":"","sources":["../../src/protocol.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AAEH,MAAM,CAAC,MAAM,gBAAgB,GAAG,CAAU,CAAC"}

package/dist/src/repo-sync.d.ts

@@ -0,0 +1,49 @@
+/**
+ * Keep a base repo's remote-tracking refs fresh, shared across all of its
+ * worktrees.
+ *
+ * The status/diff numbers (ahead/behind, added/removed) are computed against
+ * `origin/<base>` and `origin/<branch>` — refs that only move on `git fetch`.
+ * Nothing on the read path used to fetch, so as soon as someone pushed to the
+ * base the numbers went stale and stayed stale until an unrelated action (branch
+ * picker, Resolve) happened to fetch.
+ *
+ * This module fetches on the status-poll path, but with two properties that keep
+ * it cheap:
+ *   - Throttled per repo: at most one fetch per `intervalMs` (default 60s) for a
+ *     given base repo, regardless of how many worktrees poll.
+ *   - Coalesced: concurrent callers for the same repo (e.g. a project's 7
+ *     worktrees all polling at once) await a single in-flight fetch, so 7
+ *     worktrees still cost one fetch, not seven.
+ *
+ * A deliberate user action — opening a worktree, or the explicit Refresh — passes
+ * `force`, which bypasses only the throttle (a click means "show me origin *now*",
+ * not "within the last minute is fine"). Coalescing still holds under force, so a
+ * burst of clicks across a project's worktrees rides one in-flight fetch rather
+ * than firing several. Background polls stay throttled, so this stays cheap.
+ *
+ * Worktrees of a repo share one object/ref store, so fetching from any of their
+ * paths — or the base repo — updates the remote-tracking refs every worktree
+ * reads. We key throttling on the base repo path so that sharing holds.
+ *
+ * Best-effort throughout: an offline/no-remote fetch fails silently and the
+ * throttle still advances, so an unreachable remote isn't retried every poll.
+ */
+/** Default minimum spacing between fetches for a single base repo. */
+export declare const DEFAULT_SYNC_INTERVAL_MS = 60000;
+/**
+ * Fetch `repo`'s remote-tracking refs if it hasn't fetched within `intervalMs`.
+ * Returns when the refs are current enough to read: awaits an in-flight fetch,
+ * kicks off (and awaits) a new one when due, or returns immediately when a
+ * recent fetch already refreshed them. Never throws.
+ *
+ * Pass `force` for a deliberate open/refresh: it ignores the throttle interval
+ * (but still coalesces onto an in-flight fetch) so the caller sees origin as of
+ * right now rather than up to `intervalMs` ago.
+ */
+export declare function maybeSyncRepo(repo: string, opts?: {
+    intervalMs?: number;
+    force?: boolean;
+}): Promise<void>;
+/** Testing/reset hook: forget all per-repo throttle state. */
+export declare function resetRepoSyncState(): void;

package/dist/src/repo-sync.js

@@ -0,0 +1,83 @@
+/**
+ * Keep a base repo's remote-tracking refs fresh, shared across all of its
+ * worktrees.
+ *
+ * The status/diff numbers (ahead/behind, added/removed) are computed against
+ * `origin/<base>` and `origin/<branch>` — refs that only move on `git fetch`.
+ * Nothing on the read path used to fetch, so as soon as someone pushed to the
+ * base the numbers went stale and stayed stale until an unrelated action (branch
+ * picker, Resolve) happened to fetch.
+ *
+ * This module fetches on the status-poll path, but with two properties that keep
+ * it cheap:
+ *   - Throttled per repo: at most one fetch per `intervalMs` (default 60s) for a
+ *     given base repo, regardless of how many worktrees poll.
+ *   - Coalesced: concurrent callers for the same repo (e.g. a project's 7
+ *     worktrees all polling at once) await a single in-flight fetch, so 7
+ *     worktrees still cost one fetch, not seven.
+ *
+ * A deliberate user action — opening a worktree, or the explicit Refresh — passes
+ * `force`, which bypasses only the throttle (a click means "show me origin *now*",
+ * not "within the last minute is fine"). Coalescing still holds under force, so a
+ * burst of clicks across a project's worktrees rides one in-flight fetch rather
+ * than firing several. Background polls stay throttled, so this stays cheap.
+ *
+ * Worktrees of a repo share one object/ref store, so fetching from any of their
+ * paths — or the base repo — updates the remote-tracking refs every worktree
+ * reads. We key throttling on the base repo path so that sharing holds.
+ *
+ * Best-effort throughout: an offline/no-remote fetch fails silently and the
+ * throttle still advances, so an unreachable remote isn't retried every poll.
+ */
+import { resolve } from "node:path";
+import { simpleGit } from "simple-git";
+/** Default minimum spacing between fetches for a single base repo. */
+export const DEFAULT_SYNC_INTERVAL_MS = 60_000;
+const state = new Map();
+/**
+ * Fetch `repo`'s remote-tracking refs if it hasn't fetched within `intervalMs`.
+ * Returns when the refs are current enough to read: awaits an in-flight fetch,
+ * kicks off (and awaits) a new one when due, or returns immediately when a
+ * recent fetch already refreshed them. Never throws.
+ *
+ * Pass `force` for a deliberate open/refresh: it ignores the throttle interval
+ * (but still coalesces onto an in-flight fetch) so the caller sees origin as of
+ * right now rather than up to `intervalMs` ago.
+ */
+export async function maybeSyncRepo(repo, opts = {}) {
+    const { intervalMs = DEFAULT_SYNC_INTERVAL_MS, force = false } = opts;
+    const key = resolve(repo);
+    let s = state.get(key);
+    if (!s) {
+        s = { lastAt: 0, inflight: null };
+        state.set(key, s);
+    }
+    // A fetch is already running for this repo — ride along with it rather than
+    // starting a second one (this is the 7-worktrees-poll-at-once case). Holds
+    // even under force, so a burst of clicks costs one fetch, not one per click.
+    if (s.inflight)
+        return s.inflight;
+    // Fetched recently enough — the refs are fresh, don't hit the network. A
+    // forced (deliberate) refresh skips this and always fetches.
+    if (!force && Date.now() - s.lastAt < intervalMs)
+        return;
+    const st = s;
+    st.inflight = (async () => {
+        try {
+            await simpleGit(key).fetch(["--all", "--prune"]);
+        }
+        catch {
+            /* offline / no remote — keep the last-known refs, retry after interval */
+        }
+        finally {
+            st.lastAt = Date.now();
+            st.inflight = null;
+        }
+    })();
+    return st.inflight;
+}
+/** Testing/reset hook: forget all per-repo throttle state. */
+export function resetRepoSyncState() {
+    state.clear();
+}
+//# sourceMappingURL=repo-sync.js.map

package/dist/src/repo-sync.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"repo-sync.js","sourceRoot":"","sources":["../../src/repo-sync.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8BG;AAEH,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AACpC,OAAO,EAAE,SAAS,EAAE,MAAM,YAAY,CAAC;AAEvC,sEAAsE;AACtE,MAAM,CAAC,MAAM,wBAAwB,GAAG,MAAM,CAAC;AAS/C,MAAM,KAAK,GAAG,IAAI,GAAG,EAAqB,CAAC;AAE3C;;;;;;;;;GASG;AACH,MAAM,CAAC,KAAK,UAAU,aAAa,CACjC,IAAY,EACZ,OAAiD,EAAE;IAEnD,MAAM,EAAE,UAAU,GAAG,wBAAwB,EAAE,KAAK,GAAG,KAAK,EAAE,GAAG,IAAI,CAAC;IACtE,MAAM,GAAG,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IAC1B,IAAI,CAAC,GAAG,KAAK,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC;IACvB,IAAI,CAAC,CAAC,EAAE,CAAC;QACP,CAAC,GAAG,EAAE,MAAM,EAAE,CAAC,EAAE,QAAQ,EAAE,IAAI,EAAE,CAAC;QAClC,KAAK,CAAC,GAAG,CAAC,GAAG,EAAE,CAAC,CAAC,CAAC;IACpB,CAAC;IACD,4EAA4E;IAC5E,2EAA2E;IAC3E,6EAA6E;IAC7E,IAAI,CAAC,CAAC,QAAQ;QAAE,OAAO,CAAC,CAAC,QAAQ,CAAC;IAClC,yEAAyE;IACzE,6DAA6D;IAC7D,IAAI,CAAC,KAAK,IAAI,IAAI,CAAC,GAAG,EAAE,GAAG,CAAC,CAAC,MAAM,GAAG,UAAU;QAAE,OAAO;IAEzD,MAAM,EAAE,GAAG,CAAC,CAAC;IACb,EAAE,CAAC,QAAQ,GAAG,CAAC,KAAK,IAAI,EAAE;QACxB,IAAI,CAAC;YACH,MAAM,SAAS,CAAC,GAAG,CAAC,CAAC,KAAK,CAAC,CAAC,OAAO,EAAE,SAAS,CAAC,CAAC,CAAC;QACnD,CAAC;QAAC,MAAM,CAAC;YACP,0EAA0E;QAC5E,CAAC;gBAAS,CAAC;YACT,EAAE,CAAC,MAAM,GAAG,IAAI,CAAC,GAAG,EAAE,CAAC;YACvB,EAAE,CAAC,QAAQ,GAAG,IAAI,CAAC;QACrB,CAAC;IACH,CAAC,CAAC,EAAE,CAAC;IACL,OAAO,EAAE,CAAC,QAAQ,CAAC;AACrB,CAAC;AAED,8DAA8D;AAC9D,MAAM,UAAU,kBAAkB;IAChC,KAAK,CAAC,KAAK,EAAE,CAAC;AAChB,CAAC"}

package/dist/src/server.d.ts

@@ -0,0 +1,33 @@
+/**
+ * WSS server + message dispatch.
+ *
+ * Speaks the envelope contract only; knows nothing about Cloudflare
+ * (cloudflared dials this local port). A pluggable Codec decides whether
+ * payloads are cleartext (slices 1–4 / dev) or sealed NaCl boxes (slice 5).
+ */
+import { type Server } from "node:http";
+import { WebSocketServer } from "ws";
+import { type Keypair } from "./crypto.js";
+import { Hub } from "./hub.js";
+import { WorkspaceManager } from "./workspace.js";
+import { JobScheduler } from "./jobs/scheduler.js";
+export interface DaemonOptions {
+    port: number;
+    host: string;
+    /**
+     * Present when E2E is on. The daemon seals each socket's frames to that
+     * device's key after its `hello` handshake; without this, every socket stays
+     * cleartext (local dev / slices 1–4).
+     */
+    crypto?: {
+        self: Keypair;
+    };
+}
+export interface Daemon {
+    http: Server;
+    wss: WebSocketServer;
+    hub: Hub;
+    workspaces: WorkspaceManager;
+    jobs: JobScheduler;
+}
+export declare function startServer(opts: DaemonOptions): Promise<Daemon>;