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

package/src/internal/config.ts

@@ -1,168 +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.
-   * The list applies to every detected folder, so in Codex's `~/.agents/skills` it keeps a skill named
-   * `synced` from syncing.
-   */
-  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 agent home on this machine: Claude's `~/.claude` and each
- * `~/.claude-<name>`, and Codex's `~/.agents`, whose `skills` folder is where Codex reads a user's skills.
- *
- * 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-") || entry === ".agents")
-    .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();
-}

package/src/internal/control.ts

@@ -1,127 +0,0 @@
-import { createConnection, createServer, type Server, type Socket } from "node:net";
-import { chmodSync, rmSync } from "node:fs";
-import { CONTROL_SOCKET } from "./config";
-import type { ListedSkill } from "./wire";
-
-/**
- * The channel between the CLI and the running daemon.
- *
- * The daemon owns the sync token: it receives it from the browser and keeps it only in memory, so it is
- * never in a file and never passes through the CLI. The CLI's `login`, `logout` and `list` are requests to
- * the daemon over this channel. Messages are newline-delimited JSON; each request gets events until one that
- * ends it.
- */
-
-export type ControlRequest =
-  | { readonly type: "login" }
-  | { readonly type: "logout" }
-  /** The synced list, which the daemon fetches from the server with its token. */
-  | { readonly type: "list" };
-
-export type ControlEvent =
-  /** Sign-in has started: the CLI opens this URL in the browser, where the passkey is verified. */
-  | { readonly type: "open"; readonly url: string }
-  | { readonly type: "signedIn"; readonly machine: string }
-  | { readonly type: "signedOut"; readonly revoked: boolean }
-  | { readonly type: "list"; readonly skills: ReadonlyArray<ListedSkill> }
-  | { readonly type: "error"; readonly message: string };
-
-const isFinal = (event: ControlEvent): boolean => event.type !== "open";
-
-/** The daemon is not running, as opposed to running and refusing the request. */
-export class DaemonUnreachable extends Error {}
-
-/** Sends one request and calls `onEvent` for each event until the final one, which it resolves with. */
-export function request(message: ControlRequest, onEvent: (event: ControlEvent) => void): Promise<ControlEvent> {
-  return new Promise((resolve, reject) => {
-    let settled = false;
-    const socket = createConnection(CONTROL_SOCKET);
-    socket.on("connect", () => socket.write(`${JSON.stringify(message)}\n`));
-    socket.on("error", (cause: NodeJS.ErrnoException) => {
-      if (settled) return;
-      settled = true;
-      reject(cause.code === "ENOENT" || cause.code === "ECONNREFUSED"
-        ? new DaemonUnreachable(`the skill-sync daemon is not running (${cause.code} on ${CONTROL_SOCKET})`)
-        : cause);
-    });
-    readLines(socket, (line) => {
-      const event = JSON.parse(line) as ControlEvent;
-      onEvent(event);
-      if (isFinal(event) && !settled) {
-        settled = true;
-        socket.end();
-        resolve(event);
-      }
-    });
-    socket.on("close", () => {
-      if (!settled) {
-        settled = true;
-        reject(new Error("the daemon closed the connection without answering"));
-      }
-    });
-  });
-}
-
-/** One request being answered: send events, and end the conversation with a final one. */
-export interface Reply {
-  readonly send: (event: ControlEvent) => void;
-}
-
-/**
- * Listens on the control socket. Resolves false, without listening, when another live daemon already
- * holds it: two installs of skill-sync mean two daemons, and the second stands down rather than fight.
- */
-export async function serve(handle: (message: ControlRequest, reply: Reply) => void): Promise<Server | false> {
-  if (await answers()) return false;
-  // Nothing answered, so a socket file left here is from a daemon that died; it would block the listen.
-  if (process.platform !== "win32") rmSync(CONTROL_SOCKET, { force: true });
-
-  const server = createServer((socket) => {
-    const reply: Reply = {
-      send: (event) => {
-        if (socket.writable) socket.write(`${JSON.stringify(event)}\n`);
-        if (isFinal(event)) socket.end();
-      },
-    };
-    readLines(socket, (line) => {
-      try {
-        handle(JSON.parse(line) as ControlRequest, reply);
-      } catch (cause) {
-        reply.send({ type: "error", message: cause instanceof Error ? cause.message : String(cause) });
-      }
-    });
-    socket.on("error", () => undefined); // A CLI that went away mid-request; nothing to tell it.
-  });
-  await new Promise<void>((resolve, reject) => {
-    server.once("error", reject);
-    server.listen(CONTROL_SOCKET, () => resolve());
-  });
-  // Only this user may talk to the daemon that holds their token.
-  if (process.platform !== "win32") chmodSync(CONTROL_SOCKET, 0o600);
-  return server;
-}
-
-/** Whether a live daemon is listening on the control socket. */
-function answers(): Promise<boolean> {
-  return new Promise((resolve) => {
-    const socket = createConnection(CONTROL_SOCKET);
-    socket.on("connect", () => {
-      socket.end();
-      resolve(true);
-    });
-    socket.on("error", () => resolve(false));
-  });
-}
-
-function readLines(socket: Socket, onLine: (line: string) => void): void {
-  let buffer = "";
-  socket.on("data", (chunk) => {
-    buffer += chunk.toString();
-    let newline: number;
-    while ((newline = buffer.indexOf("\n")) >= 0) {
-      const line = buffer.slice(0, newline).trim();
-      buffer = buffer.slice(newline + 1);
-      if (line !== "") onLine(line);
-    }
-  });
-}

package/src/internal/folders.ts

@@ -1,52 +0,0 @@
-import { readFileSync } from "node:fs";
-import { join } from "node:path";
-import { detectFolders, hashBytes, listLocalFiles, type Config } from "./config";
-import {
-  skillOf, type FileHash, type FolderPrefs, type FoldersRequest, type FoldersResponse, type LocalSkill,
-} from "./wire";
-
-/**
- * What this machine tells the service about its folders, and what it hears back.
- *
- * The daemon and the CLI both register, so this lives in one place: they must describe a folder the same
- * way, or the dashboard would show whichever of them spoke last.
- */
-
-/**
- * The skills on disk in one folder, with each file's hash. Hashing every file on each check is cheap at
- * skills' size, and it is what lets the dashboard show whether this folder's copy is the synced one.
- */
-export function localSkills(folder: string, config: Config): LocalSkill[] {
-  const byName = new Map<string, FileHash[]>();
-  for (const path of listLocalFiles(folder, config.exclude)) {
-    const name = skillOf(path);
-    let hash: string;
-    try {
-      hash = hashBytes(readFileSync(join(folder, path)));
-    } catch {
-      continue; // Deleted between listing and reading; the next check reports the folder as it is.
-    }
-    byName.set(name, [...(byName.get(name) ?? []), { path, hash }]);
-  }
-  return [...byName].map(([name, files]) => ({ name, files }));
-}
-
-/** Everything registration sends, so a caller can tell when it has changed and is worth re-sending. */
-export function describe(config: Config): FoldersRequest {
-  return { folders: detectFolders().map((path) => ({ path, skills: localSkills(path, config) })) };
-}
-
-/** Registers this machine's folders and skills; returns the folders to sync and the skills in each. */
-export async function register(config: Config, request: FoldersRequest): Promise<ReadonlyArray<FolderPrefs>> {
-  const response = await fetch(`${config.endpoint}/folders`, {
-    method: "POST",
-    headers: authHeaders(config, { "content-type": "application/json" }),
-    body: JSON.stringify(request),
-  });
-  if (!response.ok) throw new Error(`POST /folders: ${response.status} ${await response.text()}`);
-  return (await response.json() as FoldersResponse).folders;
-}
-
-export function authHeaders(config: Config, extra: Record<string, string>): Record<string, string> {
-  return { authorization: `Bearer ${config.token}`, "x-skill-sync-machine": config.machine, ...extra };
-}

package/src/internal/path.ts

@@ -1,32 +0,0 @@
-/**
- * Validation for the one piece of untrusted input that becomes a filesystem path.
- *
- * Shared by the Worker and the daemon on purpose, and deliberately free of any Node import so the Worker
- * can bundle it. Both ends check: the server so one compromised client cannot poison what every machine
- * pulls, and the daemon because a server it does not control is not a thing to take paths from either.
- *
- * Without this, a pushed path of `../../.ssh/authorized_keys` is joined to the skills directory and
- * written wherever the daemon's user can write.
- */
-
-/** Long enough for any real nesting, short enough that nothing can be used to exhaust anything. */
-const MAX_LENGTH = 512;
-
-export function invalidPathReason(path: string): string | undefined {
-  if (path.length === 0 || path.length > MAX_LENGTH) return "path is empty or too long";
-  if (path.includes("\0")) return "path contains a null byte";
-  if (path.includes("\\")) return "path must use forward slashes";
-  if (path.startsWith("/")) return "path must be relative";
-  // A Windows drive letter is absolute on the machine that matters even though it has no leading slash.
-  if (/^[A-Za-z]:/.test(path)) return "path must be relative";
-
-  for (const segment of path.split("/")) {
-    if (segment === "") return "path has an empty segment";
-    if (segment === "." || segment === "..") return "path must not contain . or .. segments";
-  }
-  return undefined;
-}
-
-export function isValidPath(path: string): boolean {
-  return invalidPathReason(path) === undefined;
-}

package/src/internal/sync.ts

@@ -1,196 +0,0 @@
-import { existsSync, mkdirSync, readdirSync, readFileSync, rmdirSync, rmSync, statSync, utimesSync, writeFileSync } from "node:fs";
-import { dirname, join } from "node:path";
-import { hashBytes, listLocalFiles, type Config, type State } from "./config";
-import { invalidPathReason } from "./path";
-import { skillOf, type ListFilesResponse, type PutFileRequest } from "./wire";
-
-/**
- * One sync cycle: take every newer edit the server has, then send every newer edit this folder has.
- *
- * The latest edit wins, always. Every file carries the time it was last edited: here, the file's
- * modification time; on the server, the edit time of the version it holds. When this folder and the
- * server disagree about a file, whichever was edited later is kept, on both sides. Nothing is merged and
- * nothing is set aside, so every folder converges on the same bytes.
- *
- * A pulled file is given the server's edit time as its modification time, so the next cycle does not
- * mistake the pull for a local edit.
- */
-
-export interface Report {
-  readonly pulled: string[];
-  readonly pushed: string[];
-  readonly deletedLocally: string[];
-  /** Paths the server offered that this machine refused to write. */
-  readonly rejected: string[];
-}
-
-/** True when a report has nothing in it worth telling anyone. */
-export function isQuiet(report: Report): boolean {
-  return [report.pulled, report.pushed, report.deletedLocally, report.rejected].every((list) => list.length === 0);
-}
-
-/**
- * `skills` is the synced list. Every other skill in the folder is local to it: never pushed, never
- * overwritten, never deleted by a sync.
- */
-export async function syncOnce(config: Config, folder: string, state: State, skills: ReadonlySet<string>): Promise<Report> {
-  const report: Report = { pulled: [], pushed: [], deletedLocally: [], rejected: [] };
-  mkdirSync(folder, { recursive: true });
-
-  // A skill added to the list since last cycle may have server files older than the cursor; re-read from the start.
-  if ([...skills].some((skill) => !(state.skills ?? []).includes(skill))) state.cursor = 0;
-  state.skills = [...skills].sort();
-  // A skill removed from the list stops being tracked here. Left in `known`, its files would look deleted
-  // from this folder and the push would delete them on every machine.
-  for (const path of Object.keys(state.known)) {
-    if (!skills.has(skillOf(path))) delete state.known[path];
-  }
-
-  const present = new Set(listLocalFiles(folder, config.exclude).filter((path) => skills.has(skillOf(path))));
-  // Files deleted here since the last cycle. When they were deleted is not recorded anywhere, so the
-  // deletion counts as an edit made now: the pull leaves these paths alone and the push deletes them.
-  const deletedHere = new Set(Object.keys(state.known).filter((path) => !present.has(path)));
-
-  const ctx: Cycle = { config, folder, state, report, skills };
-  await pull(ctx, deletedHere, present);
-  await push(ctx, present);
-  return report;
-}
-
-interface Cycle {
-  readonly config: Config;
-  readonly folder: string;
-  readonly state: State;
-  readonly report: Report;
-  readonly skills: ReadonlySet<string>;
-}
-
-/** When this file was last edited here, to the millisecond the server stores. */
-const editedAt = (file: string): number => Math.floor(statSync(file).mtimeMs);
-
-async function pull(ctx: Cycle, deletedHere: ReadonlySet<string>, present: Set<string>): Promise<void> {
-  const { config, folder, state, report } = ctx;
-  const body = await (await call(config, `/files?since=${state.cursor}`)).json() as ListFilesResponse;
-
-  for (const file of body.files) {
-    // The server is not trusted to supply a path either: one bad row would otherwise write outside the
-    // skills directory on every machine that syncs.
-    const badPath = invalidPathReason(file.path);
-    if (badPath) {
-      report.rejected.push(`${file.path} (${badPath})`);
-      continue;
-    }
-    if (!ctx.skills.has(skillOf(file.path))) continue;
-    // Deleted here, which is newer than anything the server has; the push sends the deletion.
-    if (deletedHere.has(file.path)) continue;
-
-    const local = join(folder, file.path);
-    const exists = existsSync(local);
-    const localHash = exists ? hashBytes(readFileSync(local)) : undefined;
-    if (localHash === (file.hash ?? undefined)) {
-      if (file.hash === null) delete state.known[file.path];
-      else state.known[file.path] = file.hash;
-      continue;
-    }
-    // Edited here since this folder last agreed with the server, and later than the server's version:
-    // this folder's edit wins, and the push sends it.
-    if (exists && localHash !== state.known[file.path] && editedAt(local) > file.editedAt) continue;
-
-    await apply(ctx, file, present);
-  }
-
-  state.cursor = body.cursor;
-}
-
-async function push(ctx: Cycle, present: Set<string>): Promise<void> {
-  const { config, folder, state, report } = ctx;
-  for (const path of [...present]) {
-    const file = join(folder, path);
-    const bytes = readFileSync(file);
-    const hash = hashBytes(bytes);
-    if (state.known[path] === hash) continue;
-    const later = await put(config, { path, hash, content: Buffer.from(bytes).toString("base64"), editedAt: editedAt(file) });
-    if (later === undefined) {
-      state.known[path] = hash;
-      report.pushed.push(path);
-    } else {
-      await apply(ctx, { path, ...later }, present);
-    }
-  }
-
-  // A path this folder agreed on that is no longer on disk was deleted here. The server keeps the
-  // deletion, or the next machine to sync would upload the file again.
-  for (const path of Object.keys(state.known)) {
-    if (present.has(path)) continue;
-    const later = await put(config, { path, hash: null, content: null, editedAt: Date.now() });
-    if (later === undefined) {
-      delete state.known[path];
-      report.pushed.push(`${path} (deleted)`);
-    } else {
-      await apply(ctx, { path, ...later }, present);
-    }
-  }
-}
-
-/** The server's version of a file, as it answers a refused write. */
-interface ServerVersion {
-  readonly hash: string | null;
-  readonly editedAt: number;
-}
-
-/**
- * Writes the server's version of a file here: its bytes with its edit time, or a deletion. Used by the
- * pull, and by the push when the server refuses a write because it holds a later edit, so a refused write
- * settles at once rather than waiting for a pull that may never list the file again.
- */
-async function apply(ctx: Cycle, file: ServerVersion & { readonly path: string }, present: Set<string>): Promise<void> {
-  const { config, folder, state, report } = ctx;
-  const local = join(folder, file.path);
-  if (file.hash === null) {
-    rmSync(local, { force: true });
-    removeEmptyParents(folder, local);
-    present.delete(file.path);
-    delete state.known[file.path];
-    report.deletedLocally.push(file.path);
-    return;
-  }
-  const content = new Uint8Array(await (await call(config, `/content/${file.hash}`)).arrayBuffer());
-  mkdirSync(dirname(local), { recursive: true });
-  writeFileSync(local, content);
-  utimesSync(local, new Date(), new Date(file.editedAt));
-  state.known[file.path] = file.hash;
-  present.add(file.path);
-  report.pulled.push(file.path);
-}
-
-/** A deleted skill leaves no empty directory behind, which would still show up as a skill. */
-function removeEmptyParents(folder: string, file: string): void {
-  for (let dir = dirname(file); dir !== folder && dir.startsWith(folder); dir = dirname(dir)) {
-    if (readdirSync(dir).length > 0) return;
-    rmdirSync(dir);
-  }
-}
-
-/** Undefined when the server took the write; otherwise the later version it holds instead. */
-async function put(config: Config, body: Omit<PutFileRequest, "machine">): Promise<ServerVersion | undefined> {
-  const request: PutFileRequest = { ...body, machine: config.machine };
-  const response = await fetch(`${config.endpoint}/files`, {
-    method: "PUT",
-    headers: { authorization: `Bearer ${config.token}`, "content-type": "application/json" },
-    body: JSON.stringify(request),
-  });
-  if (response.status === 409) {
-    const current = await response.json() as { currentHash: string | null; currentEditedAt: number };
-    return { hash: current.currentHash, editedAt: current.currentEditedAt };
-  }
-  if (!response.ok) throw new Error(`PUT /files ${body.path}: ${response.status} ${await response.text()}`);
-  return undefined;
-}
-
-async function call(config: Config, path: string): Promise<Response> {
-  const response = await fetch(`${config.endpoint}${path}`, {
-    headers: { authorization: `Bearer ${config.token}` },
-  });
-  if (!response.ok) throw new Error(`GET ${path}: ${response.status} ${await response.text()}`);
-  return response;
-}