@jive-sh/skill-sync 0.4.1 → 0.4.2-latest-darwin-arm64

package/src/daemons/skill-sync-daemon.ts

@@ -1,367 +0,0 @@
-import { existsSync, mkdirSync, rmSync, watch, type FSWatcher } from "node:fs";
-import { createServer } from "node:http";
-import { exitWhenUninstalled } from "jive-abstract-library";
-import {
-  LEGACY_TOKEN_PATH, detectFolders, loadSettings, loadStates, saveStates, stateFor, type Config,
-} from "../internal/config";
-import { serve, type ControlRequest, type Reply } from "../internal/control";
-import { authHeaders, describe, register } from "../internal/folders";
-import { isQuiet, syncOnce, type Report } from "../internal/sync";
-import type { DaemonMessage, FolderPrefs, FolderState, HubToDaemon, ListSkillsResponse } from "../internal/wire";
-
-/**
- * Keeps every enabled skills folder on this machine identical to every other machine's.
- *
- * Folders are detected (`~/.claude*` homes). Which of them sync, and the one list of skills that syncs in
- * all of them, are held by the server and changed from the dashboard, so they survive a reinstall and
- * apply the moment they change. A skill not on the list is never pushed or pulled.
- *
- * The daemon holds a WebSocket to the service's hub. That connection is how the dashboard knows this
- * machine is running, how a preference change arrives, and how a write from another machine triggers a
- * cycle here at once. Polling stays as the fallback: every 5 minutes while connected, every 30 seconds
- * while not, so a dropped connection costs latency and never correctness.
- *
- * The sync token exists only in this process's memory. The daemon starts signed out and waits; `skill-sync
- * login` asks it, over the control socket, to sign in, and the token arrives from the browser straight to
- * this process. A restart means signing in again — the price of never writing the credential down.
- */
-
-const POLL_CONNECTED_MS = 5 * 60_000;
-const POLL_DISCONNECTED_MS = 30_000;
-/** Long enough that an editor's write-rename-write lands as one cycle, short enough to feel immediate. */
-const SETTLE_MS = 1_000;
-const PING_MS = 30_000;
-/** No pong for this long means the connection is dead even if the socket has not noticed. */
-const PONG_TIMEOUT_MS = 75_000;
-const RECONNECT_MIN_MS = 5_000;
-const RECONNECT_MAX_MS = 5 * 60_000;
-/** How long a sign-in waits for the browser before giving up. */
-const LOGIN_TIMEOUT_MS = 5 * 60_000;
-
-exitWhenUninstalled();
-
-// Versions before 0.3 wrote the token to a file. It is never read: a credential left on disk is one
-// anything that can read the home directory can copy.
-if (existsSync(LEGACY_TOKEN_PATH)) {
-  rmSync(LEGACY_TOKEN_PATH, { force: true });
-  console.log(`deleted ${LEGACY_TOKEN_PATH}; the token now lives only in this daemon's memory`);
-}
-
-const settings = loadSettings();
-if (settings === undefined) {
-  console.error("~/.jive/skill-sync.json needs an endpoint and a machine name");
-  // Zero, not one: the service manager restarts a daemon that fails, and a file nobody has fixed would
-  // only fill the log.
-  process.exit(0);
-}
-const states = loadStates();
-
-/** Set while signed in. Everything that talks to the server reads it; signing out clears it. */
-let session: Config | undefined;
-/** The signed-in config, for code that only runs during a session. */
-function current(): Config {
-  if (session === undefined) throw new Error("not signed in");
-  return session;
-}
-
-/** What was last registered, so registration is repeated only when a folder or skill appears or goes. */
-let registered = "";
-/** The enabled folders, each with the synced list. */
-let prefs = new Map<string, ReadonlySet<string>>();
-const watchers = new Map<string, FSWatcher>();
-
-// ── Folders ─────────────────────────────────────────────────────────────────────────────────────────
-
-/** Reports this machine's folders and skills, and adopts the server's answer for what syncs. */
-async function registerFolders(): Promise<void> {
-  const request = describe(current());
-  applyPrefs(await register(current(), request));
-  registered = JSON.stringify(request);
-}
-
-/** True when a folder or a skill has appeared or gone since the last registration. */
-const registrationStale = (): boolean => JSON.stringify(describe(current())) !== registered;
-
-function applyPrefs(folders: ReadonlyArray<FolderPrefs>): void {
-  // Only folders this machine still has. The hub can hold a stale list — it answers a reconnect before
-  // the next registration — and creating a listed folder whose Claude home is gone would bring it back.
-  const present = new Set(detectFolders());
-  const next = new Map(folders.filter((folder) => present.has(folder.path))
-    .map((folder) => [folder.path, new Set(folder.skills)] as const));
-  for (const [folder, watcher] of watchers) {
-    if (!next.has(folder)) {
-      watcher.close();
-      watchers.delete(folder);
-    }
-  }
-  // An unticked folder leaves no trace of syncing: its state goes, so the state file lists only folders
-  // that sync, and ticking it again starts it fresh.
-  // Covers folders with state from an earlier run too, not only ones this run was syncing.
-  const stopped = [...new Set([...prefs.keys(), ...Object.keys(states)])].filter((folder) => !next.has(folder));
-  for (const folder of stopped) {
-    delete states[folder];
-    console.log(`stopped syncing ${folder}`);
-  }
-  if (stopped.length > 0) saveStates(states);
-  for (const folder of next.keys()) {
-    if (watchers.has(folder)) continue;
-    mkdirSync(folder, { recursive: true });
-    let settle: ReturnType<typeof setTimeout> | undefined;
-    watchers.set(folder, watch(folder, { recursive: true }, () => {
-      if (settle !== undefined) clearTimeout(settle);
-      settle = setTimeout(runCycle, SETTLE_MS);
-    }));
-  }
-  const changed = JSON.stringify([...next].map(([path, skills]) => [path, [...skills].sort()]))
-    !== JSON.stringify([...prefs].map(([path, skills]) => [path, [...skills].sort()]));
-  prefs = next;
-  if (!changed) return;
-  for (const [folder, skills] of prefs) console.log(`syncing ${folder}: ${[...skills].sort().join(", ") || "no skills"}`);
-  if (prefs.size === 0) console.log("syncing no folders");
-  void runCycle();
-}
-
-// ── Hub connection ──────────────────────────────────────────────────────────────────────────────────
-
-let socket: WebSocket | undefined;
-let lastPong = 0;
-let reconnectDelay = RECONNECT_MIN_MS;
-/** What the hub was last told about each folder (state and detail), so only changes are sent. */
-const reported = new Map<string, string>();
-
-function connect(): void {
-  if (session === undefined) return;
-  const config = session;
-  const url = `${config.endpoint.replace(/^http/, "ws")}/daemon`;
-  // Bun's WebSocket takes headers; the browser's does not, which is why the token can travel this way.
-  const ws = new WebSocket(url, { headers: authHeaders(config, {}) } as unknown as string[]);
-  ws.onopen = () => {
-    socket = ws;
-    lastPong = Date.now();
-    reconnectDelay = RECONNECT_MIN_MS;
-    console.log("connected to the hub");
-    // Whatever the hub last heard from a previous connection is stale until re-sent.
-    reported.clear();
-    for (const folder of prefs.keys()) report(folder, "idle");
-  };
-  ws.onmessage = (event) => {
-    const data = String(event.data);
-    if (data === "pong") {
-      lastPong = Date.now();
-      return;
-    }
-    const message = JSON.parse(data) as HubToDaemon;
-    if (message.type === "prefs") applyPrefs(message.folders);
-    if (message.type === "changed") void runCycle();
-  };
-  ws.onclose = () => {
-    if (socket === ws) socket = undefined;
-    // Only the session that opened it reconnects: after a sign-out, or a sign-in with a new token, this
-    // socket belongs to nobody.
-    if (session !== config) return;
-    setTimeout(connect, reconnectDelay);
-    reconnectDelay = Math.min(reconnectDelay * 2, RECONNECT_MAX_MS);
-  };
-  ws.onerror = () => {
-    // `onclose` follows and schedules the reconnect.
-  };
-}
-
-setInterval(() => {
-  if (socket === undefined) return;
-  if (Date.now() - lastPong > PONG_TIMEOUT_MS) {
-    console.error("hub connection went quiet; reconnecting");
-    socket.close();
-    return;
-  }
-  socket.send("ping");
-}, PING_MS);
-
-function report(folder: string, state: FolderState, detail?: string, activity?: string): void {
-  const key = `${state}|${detail ?? ""}`;
-  if (reported.get(folder) === key && activity === undefined) return;
-  if (socket === undefined) return;
-  const message: DaemonMessage = { type: "status", folder, state, detail, activity };
-  socket.send(JSON.stringify(message));
-  reported.set(folder, key);
-}
-
-// ── Sync cycles ─────────────────────────────────────────────────────────────────────────────────────
-
-let running = false;
-let cycleQueued = false;
-
-function summarise(result: Report): string {
-  const parts = [
-    result.pulled.length > 0 ? `pulled ${result.pulled.join(", ")}` : "",
-    result.pushed.length > 0 ? `pushed ${result.pushed.join(", ")}` : "",
-    result.deletedLocally.length > 0 ? `deleted ${result.deletedLocally.join(", ")}` : "",
-  ];
-  return parts.filter(Boolean).join("; ");
-}
-
-async function runCycle(): Promise<void> {
-  if (session === undefined) return;
-  if (running) {
-    cycleQueued = true;
-    return;
-  }
-  running = true;
-  try {
-    // Folders sync one after another against the same server, so a change pushed from one folder is
-    // pulled into the others on the follow-up pass this triggers.
-    for (const [folder, skills] of [...prefs]) {
-      try {
-        const result = await syncOnce(current(), folder, stateFor(states, folder), skills);
-        saveStates(states);
-        log(folder, result);
-        if (result.rejected.length > 0) report(folder, "attention", result.rejected.join("; "), summarise(result) || undefined);
-        else report(folder, "idle", undefined, isQuiet(result) ? undefined : summarise(result));
-        // What this folder pushed is pulled into the machine's other folders on the follow-up pass.
-        if (result.pushed.length > 0) cycleQueued = true;
-      } catch (cause) {
-        // One failed folder must not end the daemon or the other folders: the usual cause is the network.
-        const reason = cause instanceof Error ? cause.message : String(cause);
-        console.error(`${folder}: sync failed: ${reason}`);
-        report(folder, "attention", `sync failed: ${reason}`);
-      }
-    }
-    // A skill created or removed locally changes what the dashboard should list.
-    if (registrationStale()) await registerFolders().catch(() => undefined);
-  } finally {
-    running = false;
-    if (cycleQueued) {
-      cycleQueued = false;
-      setTimeout(runCycle, SETTLE_MS);
-    }
-  }
-}
-
-function log(folder: string, result: Report): void {
-  for (const path of result.pulled) console.log(`${folder}: pulled ${path}`);
-  for (const path of result.pushed) console.log(`${folder}: pushed ${path}`);
-  for (const path of result.deletedLocally) console.log(`${folder}: deleted ${path}`);
-  for (const path of result.rejected) console.error(`${folder}: refused a path the server sent: ${path}`);
-}
-
-let pollTimer: ReturnType<typeof setTimeout> | undefined;
-
-/** Re-detects folders each poll: a Claude home created since the last one should join without a restart. */
-async function poll(): Promise<void> {
-  if (session === undefined) return;
-  try {
-    if (registered === "" || registrationStale()) await registerFolders();
-  } catch (cause) {
-    console.error(`could not register folders: ${cause instanceof Error ? cause.message : String(cause)}`);
-  }
-  await runCycle();
-  if (session !== undefined) pollTimer = setTimeout(poll, socket === undefined ? POLL_DISCONNECTED_MS : POLL_CONNECTED_MS);
-}
-
-// ── Signing in and out ──────────────────────────────────────────────────────────────────────────────
-
-/**
- * Starts a session with a token from the browser. Registering this machine's folders is the first call
- * that needs the token, so it doubles as the check that the token works: a failure leaves the daemon
- * signed out, not half-running.
- */
-async function signIn(token: string): Promise<void> {
-  if (session !== undefined) await signOut();
-  session = { ...settings!, token };
-  try {
-    await registerFolders();
-  } catch (cause) {
-    session = undefined;
-    throw cause;
-  }
-  console.log(`signed in as ${session.machine}; syncing with ${session.endpoint}`);
-  connect();
-  void poll();
-}
-
-/** Revokes the token on the server, forgets it, and stops syncing. Returns whether the revoke succeeded. */
-async function signOut(): Promise<boolean> {
-  const config = session;
-  if (config === undefined) return false;
-  session = undefined;
-  if (pollTimer !== undefined) clearTimeout(pollTimer);
-  socket?.close();
-  socket = undefined;
-  for (const watcher of watchers.values()) watcher.close();
-  watchers.clear();
-  prefs = new Map();
-  registered = "";
-  // Revoked, not just forgotten: a token copied while it was live would otherwise keep working.
-  const revoked = await fetch(`${config.endpoint}/cli/token`, { method: "DELETE", headers: authHeaders(config, {}) })
-    .then((response) => response.ok, () => false);
-  console.log(`signed out${revoked ? "" : " (the server could not be reached to revoke the token)"}`);
-  return revoked;
-}
-
-let loginInProgress = false;
-
-/**
- * One sign-in: listen on 127.0.0.1 for the browser to hand over the token, tell the CLI which URL to
- * open, and finish when the token arrives. The browser's login page posts to this listener only, never to
- * an address the request chose, so a page that tricks you into signing in cannot collect the token.
- */
-function login(reply: Reply): void {
-  if (loginInProgress) {
-    reply.send({ type: "error", message: "a sign-in is already in progress" });
-    return;
-  }
-  loginInProgress = true;
-  const done = (): void => {
-    loginInProgress = false;
-    listener.close();
-    clearTimeout(timer);
-  };
-  const listener = createServer((request, response) => {
-    const token = new URL(request.url ?? "/", "http://127.0.0.1").searchParams.get("token");
-    response.writeHead(200, { "content-type": "text/html" });
-    response.end(token ? "<p>Signed in. You can close this tab.</p>" : "<p>No token in the redirect.</p>");
-    if (token === null) return;
-    done();
-    signIn(token).then(
-      () => reply.send({ type: "signedIn", machine: settings!.machine }),
-      (cause) => reply.send({ type: "error", message: `the server refused the sign-in: ${cause instanceof Error ? cause.message : String(cause)}` }),
-    );
-  });
-  const timer = setTimeout(() => {
-    done();
-    reply.send({ type: "error", message: "timed out waiting for the browser" });
-  }, LOGIN_TIMEOUT_MS);
-  listener.listen(0, "127.0.0.1", () => {
-    const port = (listener.address() as { port: number }).port;
-    reply.send({ type: "open", url: `${settings!.endpoint}/cli/login?port=${port}&machine=${encodeURIComponent(settings!.machine)}` });
-  });
-}
-
-/** The synced list, from the server: the CLI has no token to ask with, so it asks this daemon. */
-function list(reply: Reply): void {
-  const config = session;
-  if (config === undefined) {
-    reply.send({ type: "error", message: "this machine is signed out; run `skill-sync login` first" });
-    return;
-  }
-  fetch(`${config.endpoint}/skills`, { headers: authHeaders(config, {}) })
-    .then(async (response) => {
-      if (!response.ok) throw new Error(`GET /skills: ${response.status} ${await response.text()}`);
-      reply.send({ type: "list", skills: (await response.json() as ListSkillsResponse).skills });
-    })
-    .catch((cause: unknown) => reply.send({ type: "error", message: `could not reach the server: ${cause instanceof Error ? cause.message : String(cause)}` }));
-}
-
-function handleControl(message: ControlRequest, reply: Reply): void {
-  if (message.type === "login") login(reply);
-  else if (message.type === "logout") void signOut().then((revoked) => reply.send({ type: "signedOut", revoked }));
-  else if (message.type === "list") list(reply);
-  else reply.send({ type: "error", message: `unknown request ${JSON.stringify(message)}` });
-}
-
-if (await serve(handleControl) === false) {
-  console.log("another skill-sync daemon is already running for this user; standing down");
-  // Zero: a second install's daemon is not a failure, and the service manager must not keep retrying it.
-  process.exit(0);
-}
-console.log(`skill-sync daemon for ${settings.machine}; waiting for \`skill-sync login\``);

package/src/entrypoints/skill-sync.ts

@@ -1,135 +0,0 @@
-import { spawn, spawnSync } from "node:child_process";
-import { Command } from "commander";
-import { Effect } from "effect";
-import { daemonStatuses, upgrade } from "jive-abstract-library";
-import { name } from "../../package.json";
-import { DaemonUnreachable, request, type ControlEvent, type ControlRequest } from "../internal/control";
-
-/**
- * The CLI that accompanies the daemon: `login`, `logout`, `list` and `upgrade`, and nothing else — which
- * folders and skills sync is chosen on the dashboard.
- *
- * The daemon owns the sync token and keeps it only in memory. `login`, `logout` and `list` are requests to
- * it over the control socket; the token goes from the browser straight to the daemon and never through here.
- */
-
-const program = new Command("skill-sync")
-  .description("keep the skills you choose identical across every Claude folder on every machine; choose them at https://skill-sync.jive.sh/");
-
-program
-  .command("login")
-  .description("sign this machine in with your passkey in the browser; the daemon keeps the token in memory")
-  .action(async () => {
-    const result = await withDaemon({ type: "login" }, (event) => {
-      if (event.type !== "open") return;
-      console.log(`Opening ${event.url}`);
-      openBrowser(event.url);
-    });
-    if (result.type === "signedIn") {
-      console.log(`Signed in. ${result.machine} is syncing; choose what syncs at https://skill-sync.jive.sh/`);
-    } else {
-      fail(result);
-    }
-  });
-
-program
-  .command("logout")
-  .description("revoke this machine's token and stop syncing until the next login")
-  .action(async () => {
-    const result = await withDaemon({ type: "logout" }, () => undefined);
-    if (result.type === "signedOut") {
-      console.log(result.revoked ? "Signed out; the token is revoked." : "Signed out locally; the server could not be reached to revoke the token.");
-    } else {
-      fail(result);
-    }
-  });
-
-program
-  .command("list")
-  .description("list the skills that sync, as the server holds them; needs this machine signed in")
-  .action(async () => {
-    const result = await withDaemon({ type: "list" }, () => undefined);
-    if (result.type !== "list") fail(result);
-    if (result.skills.length === 0) {
-      console.log("No skills sync yet; tick them at https://skill-sync.jive.sh/");
-      return;
-    }
-    const width = Math.max(...result.skills.map((skill) => skill.name.length));
-    for (const skill of result.skills) {
-      const detail = skill.editedAt === null
-        ? "no files yet"
-        : `${skill.files} ${skill.files === 1 ? "file" : "files"}, last edited ${new Date(skill.editedAt).toLocaleString()} on ${skill.editedBy}`;
-      console.log(`${skill.name.padEnd(width)}  ${detail}`);
-    }
-  });
-
-program
-  .command("upgrade")
-  .description("upgrade skill-sync to the latest version with the package manager that installed it")
-  .action(async () => {
-    await Effect.runPromise(upgrade({ packageName: name })).catch((cause: unknown) => {
-      console.error(`Upgrade failed: ${cause instanceof Error ? cause.message : String(cause)}`);
-      process.exit(1);
-    });
-  });
-
-program.parse();
-if (process.argv.length <= 2) program.help();
-
-/**
- * Sends a request to the running daemon. If none is listening — stopped, or never started since the
- * install — this package's registered daemon is started through its service manager and the request is
- * retried for a few seconds.
- */
-async function withDaemon(message: ControlRequest, onEvent: (event: ControlEvent) => void): Promise<ControlEvent> {
-  try {
-    return await request(message, onEvent);
-  } catch (cause) {
-    if (!(cause instanceof DaemonUnreachable)) throw cause;
-  }
-  await startDaemons();
-  for (let attempt = 0; ; attempt++) {
-    await new Promise((resolve) => setTimeout(resolve, 500));
-    try {
-      return await request(message, onEvent);
-    } catch (cause) {
-      if (!(cause instanceof DaemonUnreachable) || attempt >= 20) {
-        console.error(`${cause instanceof Error ? cause.message : String(cause)}. Reinstall skill-sync to register its daemon.`);
-        process.exit(1);
-      }
-    }
-  }
-}
-
-function fail(event: ControlEvent): never {
-  console.error(event.type === "error" ? event.message : `unexpected answer from the daemon: ${JSON.stringify(event)}`);
-  process.exit(1);
-}
-
-/** Starts this package's registered daemons through their service manager. */
-async function startDaemons(): Promise<void> {
-  const statuses = await Effect.runPromise(daemonStatuses).catch(() => []);
-  const ours = statuses.filter((status) => status.registration.packageName === name && status.executableExists);
-  if (ours.length === 0) {
-    return;
-  }
-  for (const { registration } of ours) {
-    const command: string[] = registration.kind === "launchd"
-      ? ["launchctl", "kickstart", "-k", `gui/${process.getuid?.() ?? 0}/${registration.unit}`]
-      : registration.kind === "systemd"
-        ? ["systemctl", "--user", "restart", registration.unit]
-        : ["schtasks", "/Run", "/TN", registration.unit];
-    const result = spawnSync(command[0]!, command.slice(1), { stdio: ["ignore", "ignore", "pipe"] });
-    if (result.status !== 0) {
-      console.error(`Could not start ${registration.unit}: ${String(result.stderr ?? "").trim() || `exit ${result.status}`}`);
-    }
-  }
-}
-
-function openBrowser(url: string): void {
-  const command = process.platform === "darwin" ? "open"
-    : process.platform === "win32" ? "cmd"
-    : "xdg-open";
-  const args = process.platform === "win32" ? ["/c", "start", "", url] : [url];
-  spawn(command, args, { stdio: "ignore", detached: true }).unref();
-}

package/src/index.ts

@@ -1,15 +0,0 @@
-/**
- * What the service needs from this package.
- *
- * The daemon and CLI are the product; this entrypoint exists so the service can share the path rules
- * and wire types rather than restate them. A rule restated is a rule that drifts, and these two are
- * exactly the pair that must not: one validates what the other writes to disk.
- */
-
-export { invalidPathReason, isValidPath } from "./internal/path";
-export { skillOf } from "./internal/wire";
-export type {
-  DaemonMessage, DashboardMessage, FileHash, FolderPrefs, FolderState, FolderView, FoldersRequest, FoldersResponse,
-  HubToDaemon, ListedSkill, ListFilesResponse, ListSkillsResponse, LocalSkill, MachineView, PutFileRequest, RemoteFile,
-  SkillView, Snapshot, SyncedSkill,
-} from "./internal/wire";

package/src/internal/config.ts

@@ -1,165 +0,0 @@
-import { createHash } from "node:crypto";
-import { mkdirSync, readFileSync, writeFileSync, existsSync, readdirSync, statSync } from "node:fs";
-import { homedir, hostname, userInfo } from "node:os";
-import { join, relative, sep } from "node:path";
-
-/**
- * Per-machine settings and sync state, both under `~/.jive/`. The sync token is not here: it lives only in
- * the running daemon's memory.
- *
- * A file rather than environment variables: the endpoint and which machine this is differ per computer
- * and have to survive a login, which is exactly what a config file is for and exactly what an environment
- * variable is not. Which folders to sync is not in here: they are detected, and the choice to leave one
- * out is kept on the server so the dashboard can change it and a reinstalled daemon still remembers it.
- */
-
-const JIVE_HOME = join(homedir(), ".jive");
-export const CONFIG_PATH = join(JIVE_HOME, "skill-sync.json");
-const STATE_PATH = join(JIVE_HOME, "skill-sync-state.json");
-/**
- * Where versions before 0.3 kept the sync token. The token now lives only in the running daemon's memory,
- * so the daemon deletes this file whenever it finds one: a credential left on disk is one anything that
- * can read the home directory can copy.
- */
-export const LEGACY_TOKEN_PATH = join(homedir(), ".skill-sync-token.json");
-/**
- * How the CLI reaches the running daemon: a Unix socket in `~/.jive/`, or a named pipe on Windows. Only
- * this user can open either, which is what lets the CLI hand the daemon work that involves the token.
- */
-export const CONTROL_SOCKET = process.platform === "win32"
-  ? `\\\\.\\pipe\\jive-skill-sync-${userInfo().username}`
-  : join(JIVE_HOME, "skill-sync.sock");
-
-/** Managed by Claude's own cloud sync; see `Settings.exclude`. */
-const DEFAULT_EXCLUDE = ["synced"] as const;
-
-/** What `~/.jive/skill-sync.json` holds: nothing secret, so it can live in a file. */
-export interface Settings {
-  readonly endpoint: string;
-  /**
-   * Top-level directory names under each synced folder to leave alone.
-   *
-   * `synced` holds the skills Claude already pulls from the cloud itself. Syncing them here would mean
-   * two systems writing the same files, each undoing the other, and none of them are yours to edit.
-   */
-  readonly exclude: ReadonlyArray<string>;
-  /** Names this machine on the server: on the dashboard, and as the machine each edit came from. */
-  readonly machine: string;
-}
-
-/** Settings plus the token, which exists only in the daemon's memory after a sign-in. */
-export interface Config extends Settings {
-  readonly token: string;
-}
-
-/** Sync progress for one folder. Each folder syncs with the server on its own, so each has its own. */
-export interface State {
-  /** Highest server sequence number already applied. */
-  cursor: number;
-  /** Last hash this machine agreed with the server on, per relative path. Absent means never synced. */
-  known: Record<string, string>;
-  /** The synced list as of last cycle, to notice a skill being added to it. */
-  skills?: string[];
-}
-
-/** Every folder's `State`, keyed by the folder's absolute path. */
-export type States = Record<string, State>;
-
-/**
- * The settings, writing a template on first run. Undefined when the file lacks an endpoint or a machine
- * name, which only happens if someone edited it.
- */
-export function loadSettings(): Settings | undefined {
-  if (!existsSync(CONFIG_PATH)) {
-    mkdirSync(JIVE_HOME, { recursive: true });
-    writeFileSync(CONFIG_PATH, `${JSON.stringify({
-      endpoint: "https://skill-sync.jive.sh",
-      machine: machineName(),
-      exclude: DEFAULT_EXCLUDE,
-    }, null, 2)}\n`);
-  }
-  const settings = readJson<Partial<Settings>>(CONFIG_PATH);
-  if (!settings.endpoint || !settings.machine) return undefined;
-  return { endpoint: settings.endpoint, machine: settings.machine, exclude: settings.exclude ?? DEFAULT_EXCLUDE };
-}
-
-function readJson<T>(path: string): T {
-  try {
-    return JSON.parse(readFileSync(path, "utf-8")) as T;
-  } catch {
-    return {} as T;
-  }
-}
-
-/**
- * Every folder's sync state.
- *
- * Before folders were detected the file held one folder's `{ cursor, known }`, for the folder then named
- * by `skillsDir` in the settings. That state is carried over to that folder: dropping it would make the
- * folder look never-synced, and every file in it that differs from the server would become a conflict.
- */
-export function loadStates(): States {
-  const stored = readJson<Partial<State> & { folders?: States }>(STATE_PATH);
-  if (stored.folders !== undefined) return stored.folders;
-  const legacyFolder = readJson<{ skillsDir?: string }>(CONFIG_PATH).skillsDir;
-  if (legacyFolder !== undefined && stored.cursor !== undefined && stored.known !== undefined) {
-    return { [legacyFolder]: { cursor: stored.cursor, known: stored.known } };
-  }
-  return {};
-}
-
-export function stateFor(states: States, folder: string): State {
-  states[folder] ??= { cursor: 0, known: {} };
-  return states[folder];
-}
-
-export function saveStates(states: States): void {
-  mkdirSync(JIVE_HOME, { recursive: true });
-  writeFileSync(STATE_PATH, `${JSON.stringify({ folders: states }, null, 2)}\n`);
-}
-
-/** `HOSTNAME` is not set on macOS, so the template was writing "unknown" on exactly this machine. */
-function machineName(): string {
-  return hostname().replace(/\.local$/, "").replace(/[^A-Za-z0-9-]+/g, "-") || "unknown";
-}
-
-/**
- * The `skills` folder of every Claude home on this machine: `~/.claude` and each `~/.claude-<name>`.
- *
- * Every home is a candidate, whether or not it has a `skills` folder yet, so a Claude account added
- * later joins without anyone listing it. Which of them actually sync is the user's choice on the
- * dashboard; a folder that is synced and missing is created.
- */
-export function detectFolders(): string[] {
-  return readdirSync(homedir())
-    .filter((entry) => entry === ".claude" || entry.startsWith(".claude-"))
-    .filter((entry) => statSync(join(homedir(), entry)).isDirectory())
-    .map((entry) => join(homedir(), entry, "skills"))
-    .sort();
-}
-
-export function hashBytes(bytes: Uint8Array): string {
-  return createHash("sha256").update(bytes).digest("hex");
-}
-
-/**
- * Every file under a synced folder, as paths relative to it with forward slashes.
- *
- * Normalised because the same skill synced from Windows and macOS must be one row, not two.
- */
-export function listLocalFiles(folder: string, exclude: ReadonlyArray<string> = DEFAULT_EXCLUDE): string[] {
-  if (!existsSync(folder)) return [];
-
-  const found: string[] = [];
-  const walk = (dir: string, top: boolean): void => {
-    for (const entry of readdirSync(dir)) {
-      if (entry.startsWith(".")) continue;
-      if (top && exclude.includes(entry)) continue;
-      const full = join(dir, entry);
-      if (statSync(full).isDirectory()) walk(full, false);
-      else found.push(relative(folder, full).split(sep).join("/"));
-    }
-  };
-  walk(folder, true);
-  return found.sort();
-}