@headways/cli 0.2.0 → 0.3.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Headways
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/dist/{api-WUIL5TMR.js → api-2BK6MGZB.js}

@@ -2,8 +2,8 @@
 import {
   apiRequest,
   rawRequest
-} from "./chunk-QXOLSB3Q.js";
-import "./chunk-VLKLEV4U.js";
+} from "./chunk-HYEL7L5Z.js";
+import "./chunk-T2H7EXOV.js";
 export {
   apiRequest,
   rawRequest

package/dist/{chunk-QXOLSB3Q.js → chunk-HYEL7L5Z.js}

@@ -2,7 +2,7 @@
 import {
   getApiUrl,
   requireAuth
-} from "./chunk-VLKLEV4U.js";
+} from "./chunk-T2H7EXOV.js";
 
 // src/lib/api.ts
 async function rawRequest(path, token, options = {}, apiUrl) {

package/dist/chunk-OZULVVQC.js

@@ -0,0 +1,411 @@
+#!/usr/bin/env node
+import {
+  HEADWAYS_DIR,
+  getApiUrl,
+  readConfig
+} from "./chunk-T2H7EXOV.js";
+
+// src/commands/sync/index.ts
+import { existsSync as existsSync2, mkdirSync as mkdirSync2, readFileSync as readFileSync2, writeFileSync as writeFileSync2, renameSync, rmSync as rmSync2 } from "fs";
+import { homedir as homedir2 } from "os";
+import { join as join2 } from "path";
+import { createGunzip } from "zlib";
+import { Readable } from "stream";
+import "stream/promises";
+import "commander";
+
+// src/commands/setup.ts
+import { existsSync, mkdirSync, readFileSync, rmSync, writeFileSync } from "fs";
+import { homedir } from "os";
+import { dirname, join } from "path";
+import "commander";
+var CLAUDE_SETTINGS_GLOBAL = join(homedir(), ".claude", "settings.json");
+var CLAUDE_SETTINGS_LOCAL = join(".claude", "settings.json");
+var PRIME_HOOK = { type: "command", command: "headways prime" };
+var CLAUDE_MD_SECTION = `
+<!-- BEGIN HEADWAYS -->
+## Headways Skills
+
+This project uses [Headways](https://headways.ai) for AI skill management.
+
+- \`headways prime\` \u2014 load workflow context (called automatically by hooks)
+- \`headways sync start\` \u2014 pull latest skill updates from your org
+- \`headways accept <skill>\` \u2014 install a pending skill update
+- \`headways skills list\` \u2014 list skills in your org
+
+Skills are installed to \`~/.claude/skills/<slug>/\` and loaded automatically by Claude Code.
+<!-- END HEADWAYS -->
+`.trimStart();
+function registerUninstallCommand(program) {
+  program.command("uninstall").description("Remove all Headways hooks, skill files, and local state").option("--yes", "Skip confirmation prompt").action(async (opts) => {
+    const { createInterface } = await import("readline/promises");
+    if (!opts.yes) {
+      const rl = createInterface({ input: process.stdin, output: process.stdout });
+      const ans = await rl.question(
+        "This will remove all local Headways data (hooks, skill files, config). Continue? [y/N] "
+      );
+      rl.close();
+      if (ans.trim().toLowerCase() !== "y") {
+        console.log("Aborted.");
+        return;
+      }
+    }
+    removeHooks(CLAUDE_SETTINGS_GLOBAL);
+    removeHooks(CLAUDE_SETTINGS_LOCAL);
+    console.log("\u2713 Removed Claude Code hooks");
+    const skillsDir = join(homedir(), ".claude", "skills");
+    if (existsSync(skillsDir)) {
+      rmSync(skillsDir, { recursive: true, force: true });
+      console.log("\u2713 Removed ~/.claude/skills/");
+    }
+    const headwaysDir = join(homedir(), ".headways");
+    if (existsSync(headwaysDir)) {
+      rmSync(headwaysDir, { recursive: true, force: true });
+      console.log("\u2713 Removed ~/.headways/");
+    }
+    console.log(
+      "\nHeadways data removed. You can now delete the Headways.app from /Applications."
+    );
+  });
+}
+function registerSetupCommand(program) {
+  const setup = program.command("setup").description("Install Headways integration for AI coding assistants");
+  setup.command("claude").description("Install Claude Code hooks (SessionStart + PreCompact)").option("--project", "Install for this project only (default: global)").option("--remove", "Remove the integration").option("--check", "Check if integration is installed").action((opts) => {
+    const settingsPath = opts.project ? CLAUDE_SETTINGS_LOCAL : CLAUDE_SETTINGS_GLOBAL;
+    if (opts.check) {
+      const installed = isInstalled(settingsPath);
+      console.log(
+        installed ? `\u2713 Installed: ${settingsPath}` : `\u2717 Not installed: ${settingsPath}`
+      );
+      process.exit(installed ? 0 : 1);
+    }
+    if (opts.remove) {
+      removeHooks(settingsPath);
+      console.log(`Removed Headways hooks from ${settingsPath}`);
+      return;
+    }
+    installHooks(settingsPath, opts.project ?? false);
+    updateClaudeMd(opts.project ?? false);
+  });
+}
+function ensureClaudeHooks() {
+  if (!isInstalled(CLAUDE_SETTINGS_GLOBAL)) {
+    installHooks(CLAUDE_SETTINGS_GLOBAL, false, true);
+  }
+}
+function readSettings(path) {
+  if (!existsSync(path)) return {};
+  try {
+    return JSON.parse(readFileSync(path, "utf8"));
+  } catch {
+    return {};
+  }
+}
+function writeSettings(path, settings) {
+  mkdirSync(dirname(path), { recursive: true });
+  writeFileSync(path, JSON.stringify(settings, null, 2) + "\n");
+}
+function isInstalled(settingsPath) {
+  const s = readSettings(settingsPath);
+  const hooks = s["hooks"];
+  if (!hooks) return false;
+  return ["SessionStart", "PreCompact"].every(
+    (event) => hooks[event]?.some(
+      (entry) => entry.hooks?.some((h) => h.command === PRIME_HOOK.command)
+    )
+  );
+}
+function installHooks(settingsPath, isProject, silent = false) {
+  const settings = readSettings(settingsPath);
+  const hooks = settings["hooks"] ?? {};
+  for (const event of ["SessionStart", "PreCompact"]) {
+    const entries = hooks[event] ?? [];
+    for (const entry of entries) {
+      entry.hooks = entry.hooks.filter((h) => h.command !== PRIME_HOOK.command);
+    }
+    const mainEntry = entries.find((e) => e.matcher === "" || e.matcher === void 0);
+    if (mainEntry) {
+      mainEntry.hooks.push(PRIME_HOOK);
+    } else {
+      entries.unshift({ matcher: "", hooks: [PRIME_HOOK] });
+    }
+    hooks[event] = entries;
+  }
+  settings["hooks"] = hooks;
+  writeSettings(settingsPath, settings);
+  if (!silent) {
+    console.log(`\u2713 Hooks installed: ${settingsPath}`);
+    if (!isProject) {
+      console.log("  SessionStart + PreCompact \u2192 headways prime");
+    }
+  }
+}
+function removeHooks(settingsPath) {
+  if (!existsSync(settingsPath)) return;
+  const settings = readSettings(settingsPath);
+  const hooks = settings["hooks"] ?? {};
+  for (const event of ["SessionStart", "PreCompact"]) {
+    if (hooks[event]) {
+      for (const entry of hooks[event]) {
+        entry.hooks = entry.hooks.filter((h) => h.command !== PRIME_HOOK.command);
+      }
+    }
+  }
+  settings["hooks"] = hooks;
+  writeSettings(settingsPath, settings);
+}
+function updateClaudeMd(isProject) {
+  const claudeMdPath = isProject ? "CLAUDE.md" : join(homedir(), "CLAUDE.md");
+  if (!existsSync(claudeMdPath)) return;
+  const content = readFileSync(claudeMdPath, "utf8");
+  if (content.includes("<!-- BEGIN HEADWAYS -->")) return;
+  writeFileSync(claudeMdPath, content.trimEnd() + "\n\n" + CLAUDE_MD_SECTION);
+  console.log(`\u2713 Updated ${claudeMdPath}`);
+}
+
+// src/commands/sync/index.ts
+var PENDING_FILE = join2(HEADWAYS_DIR, "pending.json");
+var SYNC_STATE_FILE = join2(HEADWAYS_DIR, "sync-state.json");
+var INSTALLED_DIR = join2(HEADWAYS_DIR, "installed");
+function readSyncState() {
+  if (!existsSync2(SYNC_STATE_FILE)) return {};
+  try {
+    return JSON.parse(readFileSync2(SYNC_STATE_FILE, "utf8"));
+  } catch {
+    return {};
+  }
+}
+function writeSyncState(state) {
+  if (!existsSync2(HEADWAYS_DIR)) mkdirSync2(HEADWAYS_DIR, { recursive: true });
+  writeFileSync2(SYNC_STATE_FILE, JSON.stringify(state, null, 2) + "\n");
+}
+function readPending() {
+  if (!existsSync2(PENDING_FILE)) return [];
+  try {
+    return JSON.parse(readFileSync2(PENDING_FILE, "utf8"));
+  } catch {
+    return [];
+  }
+}
+function writePending(updates) {
+  if (!existsSync2(HEADWAYS_DIR)) mkdirSync2(HEADWAYS_DIR, { recursive: true });
+  writeFileSync2(PENDING_FILE, JSON.stringify(updates, null, 2) + "\n");
+}
+function deviceHeaders(state) {
+  return {
+    Authorization: `Bearer ${state.device_token ?? ""}`,
+    "x-headways-device-id": state.device_id ?? "",
+    "x-headways-timestamp": String(Math.floor(Date.now() / 1e3))
+  };
+}
+async function registerDevice(token, orgId, apiUrl) {
+  const existingId = readSyncState().device_id;
+  const pubKey = existingId ? Buffer.from(`desktop-${existingId}`).toString("base64url") : Buffer.from(`desktop-${Date.now()}-${Math.random()}`).toString("base64url");
+  const res = await fetch(`${apiUrl}/v1/sync/devices/register`, {
+    method: "POST",
+    headers: {
+      "Content-Type": "application/json",
+      Authorization: `Bearer ${token}`,
+      "x-headways-org-id": orgId
+    },
+    body: JSON.stringify({
+      publicKey: pubKey,
+      platform: process.platform === "darwin" ? "macos" : process.platform === "win32" ? "windows" : "linux",
+      hostname: (await import("os")).hostname()
+    })
+  });
+  if (!res.ok) throw new Error(`Device registration failed: ${res.status}`);
+  const data = await res.json();
+  return { device_id: data.deviceId, device_token: data.deviceToken };
+}
+async function pollCatalog(state, apiUrl) {
+  const url = state.etag ? `${apiUrl}/v1/sync/catalog?since=${encodeURIComponent(state.etag)}` : `${apiUrl}/v1/sync/catalog`;
+  const res = await fetch(url, { headers: deviceHeaders(state) });
+  if (res.status === 304) return null;
+  if (!res.ok) throw new Error(`Catalog poll failed: ${res.status}`);
+  return res.json();
+}
+async function downloadAndMaterialize(slug, version, state, apiUrl) {
+  const res = await fetch(`${apiUrl}/v1/sync/bundles/${slug}/${version}`, {
+    redirect: "follow",
+    headers: deviceHeaders(state)
+  });
+  if (!res.ok) throw new Error(`Bundle fetch failed: ${res.status}`);
+  const buf = Buffer.from(await res.arrayBuffer());
+  const skillsDir = join2(homedir2(), ".claude", "skills");
+  const dest = join2(skillsDir, slug);
+  const staging = join2(skillsDir, `.${slug}-staging`);
+  mkdirSync2(staging, { recursive: true });
+  await extractTarGz(buf, staging);
+  if (existsSync2(dest)) rmSync2(dest, { recursive: true });
+  renameSync(staging, dest);
+  mkdirSync2(INSTALLED_DIR, { recursive: true });
+  writeFileSync2(
+    join2(INSTALLED_DIR, `${slug}.json`),
+    JSON.stringify(
+      { slug, version, runtime: "claude-code", installed_at: (/* @__PURE__ */ new Date()).toISOString() },
+      null,
+      2
+    )
+  );
+  console.log(`Materialized ${slug}@${version} \u2192 ${dest}`);
+}
+async function extractTarGz(buf, destDir) {
+  const decompressed = await new Promise((resolve, reject) => {
+    const chunks = [];
+    const gunzip = createGunzip();
+    const src = Readable.from(buf);
+    src.pipe(gunzip);
+    gunzip.on("data", (chunk) => chunks.push(chunk));
+    gunzip.on("end", () => resolve(Buffer.concat(chunks)));
+    gunzip.on("error", reject);
+  });
+  let offset = 0;
+  const { writeFileSync: wf, mkdirSync: md } = await import("fs");
+  const { dirname: dirname2 } = await import("path");
+  while (offset + 512 <= decompressed.length) {
+    const header = decompressed.slice(offset, offset + 512);
+    const name = header.slice(0, 100).toString("utf8").replace(/\0/g, "").trim();
+    if (!name) break;
+    const sizeOctal = header.slice(124, 136).toString("utf8").replace(/\0/g, "").trim();
+    const size = parseInt(sizeOctal, 8) || 0;
+    const typeFlag = header[156];
+    offset += 512;
+    if (typeFlag === 53 || name.endsWith("/")) {
+      md(join2(destDir, name), { recursive: true });
+    } else if (typeFlag === 0 || typeFlag === 48 || typeFlag === void 0) {
+      const filePath = join2(destDir, name);
+      md(dirname2(filePath), { recursive: true });
+      wf(filePath, decompressed.slice(offset, offset + size));
+    }
+    offset += Math.ceil(size / 512) * 512;
+  }
+}
+function registerSyncCommands(program) {
+  const sync = program.command("sync").description("Sync skills from Headways to local Claude Code");
+  sync.command("start").description("Register device and pull latest skill catalog from Headways").option("--daemon", "Run as background daemon (60s poll loop)").action(async (opts) => {
+    const cfg = readConfig();
+    if (!cfg.token || !cfg.orgId) {
+      console.error("Not logged in. Run: headways login");
+      process.exit(1);
+    }
+    const apiUrl = getApiUrl();
+    let state = readSyncState();
+    if (!state.device_id || !state.device_token) {
+      console.log("Registering device with Headways\u2026");
+      try {
+        const deviceState = await registerDevice(cfg.token, cfg.orgId, apiUrl);
+        state = { ...state, ...deviceState };
+        writeSyncState(state);
+        console.log(`Device registered: ${state.device_id}`);
+      } catch (err) {
+        console.error(`Registration failed: ${err instanceof Error ? err.message : String(err)}`);
+        process.exit(1);
+      }
+    }
+    const doPoll = async () => {
+      try {
+        ensureClaudeHooks();
+        const delta = await pollCatalog(state, apiUrl);
+        if (!delta) {
+          console.log("Catalog up to date.");
+          return;
+        }
+        state.etag = delta.etag;
+        state.last_poll = (/* @__PURE__ */ new Date()).toISOString();
+        writeSyncState(state);
+        const pendingMap = new Map(readPending().map((p) => [p.slug, p]));
+        for (const ev of delta.events) {
+          if (ev.kind === "version_published") {
+            if (ev.channel === "auto") {
+              console.log(`Auto-installing: ${ev.skill_slug}@${ev.version}`);
+              await downloadAndMaterialize(ev.skill_slug, ev.version, state, apiUrl);
+              pendingMap.delete(ev.skill_slug);
+            } else {
+              pendingMap.set(ev.skill_slug, {
+                slug: ev.skill_slug,
+                version: ev.version,
+                user_visible_change: ev.user_visible_change,
+                channel: ev.channel,
+                capabilities_delta_empty: ev.capabilities_delta_empty
+              });
+              console.log(
+                `Queued: ${ev.skill_slug}@${ev.version}${ev.user_visible_change ? ` \u2014 ${ev.user_visible_change}` : ""}`
+              );
+            }
+          } else if (ev.kind === "skill_archived" || ev.kind === "entitlement_revoked") {
+            pendingMap.delete(ev.skill_slug);
+            console.log(`Removed: ${ev.skill_slug}`);
+          }
+        }
+        writePending([...pendingMap.values()]);
+        console.log(`Synced. ETag: ${delta.etag}`);
+      } catch (err) {
+        console.error(`Poll error: ${err instanceof Error ? err.message : String(err)}`);
+      }
+    };
+    await doPoll();
+    if (opts.daemon) {
+      console.log("Running sync daemon (60s interval). Press Ctrl-C to stop.");
+      setInterval(doPoll, 6e4);
+    }
+  });
+  sync.command("status").description("Show current sync status and pending updates").action(() => {
+    const state = readSyncState();
+    const pending = readPending();
+    if (!state.device_id) {
+      console.log("Device not registered. Run: headways sync start");
+      return;
+    }
+    console.log(`Device ID  : ${state.device_id}`);
+    console.log(`Last poll  : ${state.last_poll ?? "never"}`);
+    console.log(`Catalog ETag: ${state.etag ?? "none"}`);
+    if (pending.length === 0) {
+      console.log("\nAll skills up to date. No pending updates.");
+    } else {
+      console.log(`
+Pending updates (${pending.length}):`);
+      for (const p of pending) {
+        const change = p.user_visible_change ? ` \u2014 ${p.user_visible_change}` : "";
+        const caps = p.capabilities_delta_empty ? "" : " [CAPS CHANGED]";
+        console.log(`  ${p.slug}@${p.version}${change}${caps}`);
+      }
+      console.log("\nRun `headways skills accept <skill>` to install.");
+    }
+  });
+}
+async function acceptSkill(skillSlug) {
+  const cfg = readConfig();
+  if (!cfg.token || !cfg.orgId) {
+    console.error("Not logged in. Run: headways login");
+    process.exit(1);
+  }
+  const pending = readPending();
+  const update = pending.find((p) => p.slug === skillSlug);
+  if (!update) {
+    console.error(`No pending update for skill: ${skillSlug}`);
+    console.log("Run `headways sync status` to see pending updates.");
+    process.exit(1);
+  }
+  const state = readSyncState();
+  if (!state.device_id || !state.device_token) {
+    console.error("Device not registered. Run: headways sync start");
+    process.exit(1);
+  }
+  console.log(`Accepting ${skillSlug}@${update.version}\u2026`);
+  await downloadAndMaterialize(skillSlug, update.version, state, getApiUrl());
+  writePending(pending.filter((p) => p.slug !== skillSlug));
+  console.log(
+    `${skillSlug} is ready \u2014 invoke it in Claude Code with the skill's invocation phrase.`
+  );
+}
+
+export {
+  registerUninstallCommand,
+  registerSetupCommand,
+  readSyncState,
+  writeSyncState,
+  registerDevice,
+  registerSyncCommands,
+  acceptSkill
+};

package/dist/{chunk-VLKLEV4U.js → chunk-T2H7EXOV.js}

@@ -24,10 +24,14 @@ function getApiUrl() {
   const cfg = readConfig();
   return cfg.apiUrl ?? process.env["HEADWAYS_API_URL"] ?? "https://api.headways.ai";
 }
+function getAppUrl() {
+  const cfg = readConfig();
+  return cfg.appUrl ?? process.env["HEADWAYS_APP_URL"] ?? "https://app.headways.ai";
+}
 function requireAuth() {
   const cfg = readConfig();
   if (!cfg.token || !cfg.orgId) {
-    console.error("No API key configured. Run: headways configure");
+    console.error("No API key configured. Run: headways config");
     process.exit(1);
   }
   return { token: cfg.token, orgId: cfg.orgId };
@@ -41,5 +45,6 @@ export {
   readConfig,
   writeConfig,
   getApiUrl,
+  getAppUrl,
   requireAuth
 };

package/dist/{config-GRE3MIQL.js → config-SHMIVRAP.js}

@@ -5,16 +5,18 @@ import {
   HEADWAYS_DIR,
   INSTALLED_DIR,
   getApiUrl,
+  getAppUrl,
   readConfig,
   requireAuth,
   writeConfig
-} from "./chunk-VLKLEV4U.js";
+} from "./chunk-T2H7EXOV.js";
 export {
   CATALOG_FILE,
   CONFIG_FILE,
   HEADWAYS_DIR,
   INSTALLED_DIR,
   getApiUrl,
+  getAppUrl,
   readConfig,
   requireAuth,
   writeConfig