cc-hub-cli 1.0.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Bing Tong
+
+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/README.md

@@ -0,0 +1 @@
+# cc-hub

package/dist/index.js

@@ -0,0 +1,788 @@
+#!/usr/bin/env node
+
+// src/index.ts
+import { Command as Command4 } from "commander";
+
+// src/profiles.ts
+import { Command } from "commander";
+import Anthropic from "@anthropic-ai/sdk";
+
+// src/config.ts
+import fs from "fs";
+import path from "path";
+import os from "os";
+var CLAUDE_DIR = process.env.CLAUDE_DIR || path.join(os.homedir(), ".claude");
+var PROFILES_FILE = process.env.CLAUDE_PROFILES_FILE || path.join(CLAUDE_DIR, "profiles.json");
+var SETTINGS_FILE = process.env.CLAUDE_SETTINGS_FILE || path.join(CLAUDE_DIR, "settings.json");
+var PROJECTS_DIR = path.join(CLAUDE_DIR, "projects");
+var SESSIONS_DIR = path.join(CLAUDE_DIR, "sessions");
+function ensureFile(filePath, defaultContent) {
+  if (!fs.existsSync(filePath)) {
+    fs.mkdirSync(path.dirname(filePath), { recursive: true });
+    fs.writeFileSync(filePath, defaultContent, "utf-8");
+  }
+}
+function readJson(filePath) {
+  return JSON.parse(fs.readFileSync(filePath, "utf-8"));
+}
+function writeJson(filePath, data) {
+  fs.writeFileSync(filePath, JSON.stringify(data, null, 2) + "\n", "utf-8");
+}
+function ensureProfilesFile() {
+  ensureFile(PROFILES_FILE, '{"profiles":{}}\n');
+}
+function ensureSettingsFile() {
+  ensureFile(SETTINGS_FILE, "{}\n");
+}
+
+// src/profiles.ts
+function maskToken(token) {
+  if (!token) return "(unset)";
+  if (token.length <= 12) return token;
+  return token.slice(0, 8) + "..." + token.slice(-4);
+}
+function profileCommand() {
+  const profile = new Command("profile").description("Manage Claude CLI profiles");
+  profile.command("add").description("Add or update a profile").argument("<name>", "Profile name").option("-m, --model <model>", "Model ID (e.g. claude-opus-4-6)").option("-t, --token <token>", "API key / token").option("-u, --url <url>", "Base URL (e.g. https://api.anthropic.com)").action((name, opts) => {
+    ensureProfilesFile();
+    const data = readJson(PROFILES_FILE);
+    const profile2 = data.profiles[name] || {};
+    if (opts.model) profile2.model = opts.model;
+    if (opts.token) profile2.token = opts.token;
+    if (opts.url) profile2.url = opts.url;
+    data.profiles[name] = profile2;
+    writeJson(PROFILES_FILE, data);
+    console.log(`Profile '${name}' saved.`);
+  });
+  profile.command("update").description("Update fields of an existing profile").argument("<name>", "Profile name (must already exist)").option("-m, --model <model>", "Model ID").option("-t, --token <token>", "API key / token").option("-u, --url <url>", "Base URL").action((name, opts) => {
+    ensureProfilesFile();
+    const data = readJson(PROFILES_FILE);
+    if (!data.profiles[name]) {
+      console.error(`Profile '${name}' not found. Use 'profile add' to create it.`);
+      process.exit(1);
+    }
+    const p = data.profiles[name];
+    if (opts.model) p.model = opts.model;
+    if (opts.token) p.token = opts.token;
+    if (opts.url) p.url = opts.url;
+    writeJson(PROFILES_FILE, data);
+    console.log(`Profile '${name}' updated.`);
+  });
+  profile.command("list").description("List all profiles").action(() => {
+    ensureProfilesFile();
+    const data = readJson(PROFILES_FILE);
+    const profiles = data.profiles;
+    const names = Object.keys(profiles);
+    if (names.length === 0) {
+      console.log("No profiles defined. Use 'profile add' to create one.");
+      return;
+    }
+    const def = data.default || "";
+    const fmt = (marker, name, model, token, url) => `${marker.padEnd(2)}  ${name.padEnd(20)}  ${model.padEnd(30)}  ${token.padEnd(20)}  ${url}`;
+    console.log(fmt("", "NAME", "MODEL", "TOKEN", "URL"));
+    console.log(fmt("", "----", "-----", "-----", "---"));
+    for (const name of names) {
+      const p = profiles[name];
+      const marker = name === def ? "* " : "  ";
+      console.log(fmt(
+        marker,
+        name,
+        p.model || "(unset)",
+        maskToken(p.token || ""),
+        p.url || "(default)"
+      ));
+    }
+  });
+  profile.command("view").description("View full details of a profile (token unmasked)").argument("<name>", "Profile name").option("-j, --json", "Output as JSON").action((name, opts) => {
+    ensureProfilesFile();
+    const data = readJson(PROFILES_FILE);
+    const p = data.profiles[name];
+    if (!p) {
+      console.error(`Profile '${name}' not found.`);
+      process.exit(1);
+    }
+    if (opts.json) {
+      console.log(JSON.stringify({ name, ...p }, null, 2));
+    } else {
+      console.log(`Name:   ${name}`);
+      console.log(`Model:  ${p.model || "(unset)"}`);
+      console.log(`Token:  ${p.token || "(unset)"}`);
+      console.log(`URL:    ${p.url || "(default)"}`);
+    }
+  });
+  profile.command("remove").description("Remove a profile").argument("<name>", "Profile name").action((name) => {
+    ensureProfilesFile();
+    const data = readJson(PROFILES_FILE);
+    if (!data.profiles[name]) {
+      console.error(`Profile '${name}' not found.`);
+      process.exit(1);
+    }
+    delete data.profiles[name];
+    writeJson(PROFILES_FILE, data);
+    console.log(`Profile '${name}' removed.`);
+  });
+  profile.command("default").description("Set the default profile").argument("<name>", "Profile name to set as default").action((name) => {
+    ensureProfilesFile();
+    const data = readJson(PROFILES_FILE);
+    if (!data.profiles[name]) {
+      console.error(`Profile '${name}' not found.`);
+      process.exit(1);
+    }
+    data.default = name;
+    writeJson(PROFILES_FILE, data);
+    console.log(`Default profile set to '${name}'.`);
+  });
+  return profile;
+}
+async function runWithProfile(profileName, prompt) {
+  ensureProfilesFile();
+  const data = readJson(PROFILES_FILE);
+  const p = data.profiles[profileName];
+  if (!p) {
+    console.error(`Profile '${profileName}' not found.`);
+    process.exit(1);
+  }
+  if (!p.token) {
+    console.error(`Profile '${profileName}' has no token configured.`);
+    process.exit(1);
+  }
+  const client = new Anthropic({
+    apiKey: p.token,
+    ...p.url ? { baseURL: p.url } : {}
+  });
+  console.error(`Using profile '${profileName}': model=${p.model || "(default)"} url=${p.url || "(default)"}`);
+  const stream = client.messages.stream(
+    {
+      model: p.model || "claude-sonnet-4-20250514",
+      max_tokens: 4096,
+      messages: [{ role: "user", content: prompt }]
+    }
+  );
+  for await (const event of stream) {
+    if (event.type === "content_block_delta" && event.delta.type === "text_delta") {
+      process.stdout.write(event.delta.text);
+    }
+  }
+  process.stdout.write("\n");
+}
+function useCommand() {
+  return new Command("use").description("Launch a chat session using a saved profile").argument("<name>", "Profile name").argument("[prompt...]", "Prompt text").action(async (name, promptParts) => {
+    const prompt = promptParts.join(" ");
+    if (!prompt) {
+      ensureProfilesFile();
+      const data = readJson(PROFILES_FILE);
+      if (!data.profiles[name]) {
+        console.error(`Profile '${name}' not found.`);
+        process.exit(1);
+      }
+      data.default = name;
+      writeJson(PROFILES_FILE, data);
+      console.log(`Default profile set to '${name}'.`);
+      return;
+    }
+    await runWithProfile(name, prompt);
+  });
+}
+function runCommand() {
+  return new Command("run").description("Run a prompt using the default or a specified profile").argument("[args...]", "Optional profile name followed by prompt").action(async (args) => {
+    ensureProfilesFile();
+    const data = readJson(PROFILES_FILE);
+    let profileName = "";
+    let promptParts;
+    if (args.length > 0 && data.profiles[args[0]]) {
+      profileName = args[0];
+      promptParts = args.slice(1);
+    } else {
+      profileName = data.default || "";
+      promptParts = args;
+    }
+    if (!profileName) {
+      console.error("No default profile set. Use 'cc-hub use <name>' first.");
+      process.exit(1);
+    }
+    const prompt = promptParts.join(" ");
+    if (!prompt) {
+      console.error("No prompt provided.");
+      process.exit(1);
+    }
+    await runWithProfile(profileName, prompt);
+  });
+}
+
+// src/hooks.ts
+import { Command as Command2 } from "commander";
+function buildFlat(data) {
+  const rows = [];
+  const hooksRoot = data.hooks || {};
+  for (const [event, groups] of Object.entries(hooksRoot)) {
+    for (let gi = 0; gi < groups.length; gi++) {
+      const g = groups[gi];
+      for (let hi = 0; hi < g.hooks.length; hi++) {
+        const h = g.hooks[hi];
+        rows.push({
+          seq: h._seq || 0,
+          active: true,
+          event,
+          matcher: g.matcher || "",
+          command: h.command,
+          gi,
+          hi,
+          di: -1
+        });
+      }
+    }
+  }
+  const pool = data._cc_hub_disabled || [];
+  for (let di = 0; di < pool.length; di++) {
+    const e = pool[di];
+    rows.push({
+      seq: e._seq || 0,
+      active: false,
+      event: e.event || "?",
+      matcher: e.matcher || "",
+      command: e.command,
+      gi: -1,
+      hi: -1,
+      di
+    });
+  }
+  rows.sort((a, b) => a.seq - b.seq);
+  return rows;
+}
+function hooksCommand() {
+  const hooks = new Command2("hooks").alias("h").description("Manage Claude Code hooks in settings.json");
+  hooks.command("list").description("List all hooks").action(() => {
+    ensureSettingsFile();
+    const data = readJson(SETTINGS_FILE);
+    const rows = buildFlat(data);
+    if (rows.length === 0) {
+      console.log("No hooks defined.");
+      return;
+    }
+    const fmt = (idx, active, event, matcher, cmd) => `${String(idx).padEnd(4)}  ${active.padEnd(2)}  ${event.padEnd(22)}  ${matcher.padEnd(25)}  ${cmd}`;
+    console.log(fmt(0, "", "EVENT", "MATCHER", "COMMAND").replace(/^IDX/, "IDX").replace(/^0/, "IDX"));
+    console.log(fmt(0, "", "-----", "-------", "-------").replace(/^0/, "---"));
+    for (let idx = 0; idx < rows.length; idx++) {
+      const r = rows[idx];
+      const marker = r.active ? " " : "\u2717";
+      const matcher = r.matcher || "(any)";
+      const cmd = r.command.length > 60 ? r.command.slice(0, 60) + "\u2026" : r.command;
+      console.log(fmt(idx, marker, r.event, matcher, cmd));
+    }
+  });
+  hooks.command("add").description("Add a hook to settings.json").requiredOption("-e, --event <event>", "Hook event (PreToolUse|PostToolUse|Notification|Stop|UserPromptSubmit|PermissionRequest)").option("-m, --matcher <matcher>", "Tool name matcher (omit for catch-all)").requiredOption("-c, --command <command>", "Shell command to run").option("-a, --async", "Run the hook asynchronously").action((opts) => {
+    ensureSettingsFile();
+    const data = readJson(SETTINGS_FILE);
+    const hooksRoot = data.hooks || (data.hooks = {});
+    const groups = hooksRoot[opts.event] || (hooksRoot[opts.event] = []);
+    const matcher = opts.matcher || "";
+    let targetGroup = groups.find((g) => (g.matcher || "") === matcher);
+    if (!targetGroup) {
+      targetGroup = { hooks: [] };
+      if (matcher) targetGroup.matcher = matcher;
+      groups.push(targetGroup);
+    }
+    const seq = (data._cc_hub_seq || 0) + 1;
+    data._cc_hub_seq = seq;
+    const newHook = { type: "command", command: opts.command, _seq: seq };
+    if (opts.async) newHook.async = true;
+    targetGroup.hooks.push(newHook);
+    writeJson(SETTINGS_FILE, data);
+    console.log(`Hook added to event '${opts.event}'${matcher ? ` matcher='${matcher}'` : ""}.`);
+  });
+  hooks.command("remove").description("Remove a hook by its global index (see 'hooks list')").requiredOption("-i, --index <index>", "Global index from 'hooks list'", parseInt).action((opts) => {
+    ensureSettingsFile();
+    const data = readJson(SETTINGS_FILE);
+    const rows = buildFlat(data);
+    const target = opts.index;
+    if (target < 0 || target >= rows.length) {
+      console.error(`Index ${target} out of range (0-${rows.length - 1}).`);
+      process.exit(1);
+    }
+    const r = rows[target];
+    if (r.active) {
+      const hooksRoot = data.hooks;
+      hooksRoot[r.event][r.gi].hooks.splice(r.hi, 1);
+      hooksRoot[r.event] = hooksRoot[r.event].filter((g) => g.hooks.length > 0);
+      if (hooksRoot[r.event].length === 0) delete hooksRoot[r.event];
+    } else {
+      const pool = data._cc_hub_disabled;
+      pool.splice(r.di, 1);
+      if (pool.length === 0) delete data._cc_hub_disabled;
+    }
+    writeJson(SETTINGS_FILE, data);
+    console.log(`Hook ${target} removed.`);
+  });
+  hooks.command("enable").description("Enable one or more disabled hooks").requiredOption("-i, --index <indexes...>", "Global index from 'hooks list' (repeatable)", (v, prev) => {
+    prev = prev || [];
+    prev.push(parseInt(v));
+    return prev;
+  }).action((opts) => {
+    ensureSettingsFile();
+    const data = readJson(SETTINGS_FILE);
+    const rows = buildFlat(data);
+    const targets = [...new Set(opts.index)].sort((a, b) => a - b);
+    const errors = [];
+    for (const t of targets) {
+      if (t < 0 || t >= rows.length) errors.push(`Index ${t} out of range (0-${rows.length - 1}).`);
+      else if (rows[t].active) errors.push(`Index ${t} is already active.`);
+    }
+    if (errors.length > 0) {
+      for (const e of errors) console.error(e);
+      process.exit(1);
+    }
+    const hooksRoot = data.hooks || (data.hooks = {});
+    const pool = data._cc_hub_disabled;
+    const seqsToEnable = new Set(targets.map((t) => rows[t].seq));
+    const remaining = [];
+    const toRestore = [];
+    for (const entry of pool) {
+      if (seqsToEnable.has(entry._seq || 0)) {
+        toRestore.push(entry);
+      } else {
+        remaining.push(entry);
+      }
+    }
+    for (const entry of toRestore) {
+      const event = entry.event;
+      const matcher = entry.matcher || "";
+      const hook = { type: entry.type, command: entry.command, _seq: entry._seq, ...entry.async ? { async: true } : {} };
+      const groups = hooksRoot[event] || (hooksRoot[event] = []);
+      let grp = groups.find((g) => (g.matcher || "") === matcher);
+      if (!grp) {
+        grp = { hooks: [] };
+        if (matcher) grp.matcher = matcher;
+        groups.push(grp);
+      }
+      grp.hooks.push(hook);
+      const t = rows.findIndex((r) => r.seq === entry._seq);
+      console.log(`Hook ${t} (${event}) enabled.`);
+    }
+    data._cc_hub_disabled = remaining;
+    if (remaining.length === 0) delete data._cc_hub_disabled;
+    writeJson(SETTINGS_FILE, data);
+  });
+  hooks.command("disable").description("Disable one or more hooks (removes from active)").requiredOption("-i, --index <indexes...>", "Global index from 'hooks list' (repeatable)", (v, prev) => {
+    prev = prev || [];
+    prev.push(parseInt(v));
+    return prev;
+  }).action((opts) => {
+    ensureSettingsFile();
+    const data = readJson(SETTINGS_FILE);
+    const rows = buildFlat(data);
+    const targets = [...new Set(opts.index)].sort((a, b) => a - b);
+    const errors = [];
+    for (const t of targets) {
+      if (t < 0 || t >= rows.length) errors.push(`Index ${t} out of range (0-${rows.length - 1}).`);
+      else if (!rows[t].active) errors.push(`Index ${t} is already disabled.`);
+    }
+    if (errors.length > 0) {
+      for (const e of errors) console.error(e);
+      process.exit(1);
+    }
+    const hooksRoot = data.hooks;
+    const pool = data._cc_hub_disabled || (data._cc_hub_disabled = []);
+    for (const t of [...targets].reverse()) {
+      const r = rows[t];
+      const hook = hooksRoot[r.event][r.gi].hooks[r.hi];
+      const entry = {
+        event: r.event,
+        ...hook
+      };
+      if (r.matcher) entry.matcher = r.matcher;
+      pool.push(entry);
+      hooksRoot[r.event][r.gi].hooks.splice(r.hi, 1);
+      hooksRoot[r.event] = hooksRoot[r.event].filter((g) => g.hooks.length > 0);
+      if (hooksRoot[r.event].length === 0) delete hooksRoot[r.event];
+      console.log(`Hook ${t} (${r.event}) disabled.`);
+    }
+    writeJson(SETTINGS_FILE, data);
+  });
+  return hooks;
+}
+
+// src/sessions.ts
+import { Command as Command3 } from "commander";
+import fs2 from "fs";
+import path2 from "path";
+import { execSync } from "child_process";
+function encodePath(p) {
+  return p.replace(/\./g, "DOTMARK").replace(/\//g, "-").replace(/DOTMARK/g, "-");
+}
+function decodePath(encoded) {
+  return encoded.replace(/--/g, "/.").replace(/-/g, "/");
+}
+function formatTimestamp(ms) {
+  const d = new Date(ms);
+  const pad = (n) => String(n).padStart(2, "0");
+  return `${d.getFullYear()}-${pad(d.getMonth() + 1)}-${pad(d.getDate())} ${pad(d.getHours())}:${pad(d.getMinutes())}`;
+}
+function findProjectDir(query) {
+  const encoded = encodePath(query);
+  if (fs2.existsSync(path2.join(PROJECTS_DIR, encoded))) return encoded;
+  try {
+    const dirs = fs2.readdirSync(PROJECTS_DIR);
+    const match = dirs.find((d) => d.toLowerCase().includes(query.toLowerCase()));
+    return match || null;
+  } catch {
+    return null;
+  }
+}
+function parseSessionMeta(filePath) {
+  let started = "?";
+  let slug = "";
+  let customTitle = "";
+  try {
+    const lines = fs2.readFileSync(filePath, "utf-8").split("\n");
+    for (const line of lines) {
+      if (!line.trim()) continue;
+      try {
+        const d = JSON.parse(line);
+        if (started === "?") {
+          const ts = d.timestamp;
+          if (ts) {
+            const dt = typeof ts === "number" ? new Date(ts) : new Date(String(ts).replace("Z", "+00:00"));
+            started = formatTimestamp(dt.getTime());
+          }
+        }
+        if (!slug) slug = d.slug || "";
+        if (d.type === "custom-title") customTitle = d.customTitle || "";
+      } catch {
+      }
+    }
+  } catch {
+  }
+  return { started, slug: customTitle || slug };
+}
+function extractText(d) {
+  const message = d.message;
+  let content;
+  let role = "";
+  if (message) {
+    content = message.content;
+    role = message.role || "";
+  } else {
+    content = d.content;
+    role = d.type || d.operation || "";
+  }
+  if (Array.isArray(content)) {
+    for (const p of content) {
+      if (typeof p === "object" && p !== null && p.type === "text") {
+        return { role, text: p.text };
+      }
+    }
+  } else if (typeof content === "string") {
+    return { role, text: content };
+  }
+  return { role: "", text: "" };
+}
+function snippet(text, query, width = 150) {
+  const idx = text.toLowerCase().indexOf(query.toLowerCase());
+  if (idx === -1) return text.slice(0, width);
+  const start = Math.max(0, idx - Math.floor(width / 3));
+  const end = Math.min(text.length, start + width);
+  const prefix = start > 0 ? "..." : "";
+  const suffix = end < text.length ? "..." : "";
+  return prefix + text.slice(start, end) + suffix;
+}
+function sessionCommand() {
+  const session = new Command3("session").description("Manage Claude Code sessions");
+  session.command("list").description("List all Claude Code project sessions").option("-n, --limit <n>", "Max number of projects to show", "30").option("-s, --short", "Show encoded names only (no decoding)").option("-j, --json", "Output as JSON lines").action((opts) => {
+    const limit = parseInt(opts.limit, 10);
+    let dirs;
+    try {
+      dirs = fs2.readdirSync(PROJECTS_DIR);
+    } catch {
+      console.log("No projects directory found.");
+      return;
+    }
+    dirs.sort((a, b) => {
+      const statA = fs2.statSync(path2.join(PROJECTS_DIR, a));
+      const statB = fs2.statSync(path2.join(PROJECTS_DIR, b));
+      return statB.mtimeMs - statA.mtimeMs;
+    });
+    let count = 0;
+    for (const projDir of dirs) {
+      if (count >= limit) break;
+      const fullPath = path2.join(PROJECTS_DIR, projDir);
+      let nSessions = 0;
+      try {
+        nSessions = fs2.readdirSync(fullPath).filter((f) => f.endsWith(".jsonl")).length;
+      } catch {
+      }
+      const stat = fs2.statSync(fullPath);
+      const decoded = decodePath(projDir);
+      if (opts.json) {
+        console.log(JSON.stringify({ project: decoded, sessions: nSessions, modified: Math.floor(stat.mtimeMs) }));
+      } else if (opts.short) {
+        console.log(projDir);
+      } else {
+        console.log(`${decoded.padEnd(55)}  ${String(nSessions).padStart(3)} session(s)  ${formatTimestamp(stat.mtimeMs)}`);
+      }
+      count++;
+    }
+  });
+  session.command("show").description("Show session files for a project").argument("<project>", "Project path or encoded name (partial match ok)").option("-v, --verbose", "Show first user message of each session").action((project, opts) => {
+    const projDir = findProjectDir(project);
+    if (!projDir) {
+      console.error(`No project matched: ${project}`);
+      process.exit(1);
+    }
+    const fullPath = path2.join(PROJECTS_DIR, projDir);
+    console.log(`Project: ${decodePath(projDir)}`);
+    console.log(`Dir:     ${fullPath}`);
+    console.log("");
+    const fmt = (sid, name, started, msgs) => `${sid.padEnd(36)}  ${name.padEnd(30)}  ${started.padEnd(17)}  ${msgs}`;
+    console.log(fmt("Session ID", "Name", "Started", "Messages"));
+    console.log(fmt("----------", "----", "-------", "--------"));
+    let files;
+    try {
+      files = fs2.readdirSync(fullPath).filter((f) => f.endsWith(".jsonl"));
+    } catch {
+      return;
+    }
+    for (const file of files) {
+      const filePath = path2.join(fullPath, file);
+      const sessionId = file.replace(/\.jsonl$/, "");
+      let msgCount = 0;
+      try {
+        const content = fs2.readFileSync(filePath, "utf-8");
+        msgCount = content ? content.split("\n").filter((l) => l.trim()).length : 0;
+      } catch {
+      }
+      const { started, slug } = parseSessionMeta(filePath);
+      console.log(fmt(sessionId, slug || "-", started, String(msgCount)));
+      if (opts.verbose) {
+        try {
+          const lines = fs2.readFileSync(filePath, "utf-8").split("\n");
+          for (const line of lines) {
+            if (!line.trim()) continue;
+            try {
+              const d = JSON.parse(line);
+              if (d.type === "user") {
+                const content = d.message?.content;
+                if (Array.isArray(content)) {
+                  for (const part of content) {
+                    if (typeof part === "object" && part?.type === "text") {
+                      console.log(`  > ${part.text.slice(0, 120)}`);
+                      break;
+                    }
+                  }
+                } else if (typeof content === "string") {
+                  console.log(`  > ${content.slice(0, 120)}`);
+                }
+                break;
+              }
+            } catch {
+            }
+          }
+        } catch {
+        }
+      }
+    }
+  });
+  session.command("search").description("Search conversation history across all projects").argument("<query>", "Text to search for").option("-p, --project <project>", "Filter to a specific project (partial match)").option("-n, --limit <n>", "Max number of matching files to show", "20").option("-i, --ignore-case", "Case-insensitive search").action((query, opts) => {
+    let searchRoot = PROJECTS_DIR;
+    if (opts.project) {
+      const projDir = findProjectDir(opts.project);
+      if (!projDir) {
+        console.error(`No project matched: ${opts.project}`);
+        process.exit(1);
+      }
+      searchRoot = path2.join(PROJECTS_DIR, projDir);
+    }
+    const limit = parseInt(opts.limit, 10);
+    let count = 0;
+    function searchDir(dir) {
+      if (count >= limit) return;
+      let entries;
+      try {
+        entries = fs2.readdirSync(dir, { withFileTypes: true });
+      } catch {
+        return;
+      }
+      for (const entry of entries) {
+        if (count >= limit) break;
+        const fullPath = path2.join(dir, entry.name);
+        if (entry.isDirectory()) {
+          searchDir(fullPath);
+        } else if (entry.name.endsWith(".jsonl")) {
+          try {
+            const content = fs2.readFileSync(fullPath, "utf-8");
+            const lines = content.split("\n");
+            let found = false;
+            for (let lineno = 0; lineno < lines.length; lineno++) {
+              const line = lines[lineno];
+              if (!line.trim()) continue;
+              const match = opts.ignoreCase ? line.toLowerCase().includes(query.toLowerCase()) : line.includes(query);
+              if (match) {
+                if (!found) {
+                  const relPath = path2.relative(PROJECTS_DIR, fullPath);
+                  const projEnc = relPath.split("/")[0];
+                  const sessionId = path2.basename(fullPath, ".jsonl");
+                  console.log(`[${decodePath(projEnc)}  \u2192  ${sessionId}]`);
+                  found = true;
+                  count++;
+                }
+                try {
+                  const d = JSON.parse(line);
+                  const { role, text } = extractText(d);
+                  if (text) {
+                    console.log(`  line ${lineno + 1} [${role}]: ${snippet(text, query)}`);
+                  } else {
+                    console.log(`  line ${lineno + 1}: ${line.slice(0, 140)}`);
+                  }
+                } catch {
+                  console.log(`  line ${lineno + 1}: ${line.slice(0, 140)}`);
+                }
+                const matchCount = lines.slice(0, lineno + 1).filter((l, i) => {
+                  if (i > lineno) return false;
+                  return opts.ignoreCase ? l.toLowerCase().includes(query.toLowerCase()) : l.includes(query);
+                }).length;
+                if (matchCount >= 5) break;
+              }
+            }
+            if (found) console.log("");
+          } catch {
+          }
+        }
+      }
+    }
+    searchDir(searchRoot);
+  });
+  session.command("ps").description("Show active Claude Code processes").action(() => {
+    let files;
+    try {
+      files = fs2.readdirSync(SESSIONS_DIR).filter((f) => f.endsWith(".json"));
+    } catch {
+      console.log("(no session files found)");
+      return;
+    }
+    if (files.length === 0) {
+      console.log("(no session files found)");
+      return;
+    }
+    const fmt = (pid, sid, started, cwd, status) => `${pid.padEnd(8)}  ${sid.padEnd(40)}  ${started.padEnd(20)}  ${cwd}${status}`;
+    console.log(fmt("PID", "Session ID", "Started", "CWD", ""));
+    console.log(fmt("---", "----------", "-------", "---", ""));
+    for (const file of files) {
+      try {
+        const data = JSON.parse(fs2.readFileSync(path2.join(SESSIONS_DIR, file), "utf-8"));
+        const pid = String(data.pid || "?");
+        const sessionId = data.sessionId || "?";
+        const cwd = data.cwd || "?";
+        const startedMs = data.startedAt || 0;
+        let alive = " [dead]";
+        try {
+          process.kill(Number(pid), 0);
+          alive = " [running]";
+        } catch {
+        }
+        console.log(fmt(pid, sessionId, formatTimestamp(startedMs), cwd, alive));
+      } catch {
+      }
+    }
+  });
+  session.command("stats").description("Show summary statistics across all Claude Code sessions").action(() => {
+    let nProjects = 0;
+    let nSessions = 0;
+    let totalMsgs = 0;
+    let nActive = 0;
+    try {
+      nProjects = fs2.readdirSync(PROJECTS_DIR).length;
+    } catch {
+    }
+    try {
+      const walk = (dir) => {
+        const results = [];
+        try {
+          for (const entry of fs2.readdirSync(dir, { withFileTypes: true })) {
+            const fullPath = path2.join(dir, entry.name);
+            if (entry.isDirectory()) results.push(...walk(fullPath));
+            else if (entry.name.endsWith(".jsonl")) results.push(fullPath);
+          }
+        } catch {
+        }
+        return results;
+      };
+      const sessionFiles = walk(PROJECTS_DIR);
+      nSessions = sessionFiles.length;
+      for (const f of sessionFiles) {
+        try {
+          const content = fs2.readFileSync(f, "utf-8");
+          totalMsgs += content ? content.split("\n").filter((l) => l.trim()).length : 0;
+        } catch {
+        }
+      }
+    } catch {
+    }
+    try {
+      nActive = fs2.readdirSync(SESSIONS_DIR).filter((f) => f.endsWith(".json")).length;
+    } catch {
+    }
+    console.log(`Projects:        ${nProjects}`);
+    console.log(`Sessions:        ${nSessions}`);
+    console.log(`Total messages:  ${totalMsgs}`);
+    console.log(`Active procs:    ${nActive}  (in ${SESSIONS_DIR})`);
+    console.log("");
+    try {
+      const totalSize = execSync(`du -sh "${path2.join(process.env.CLAUDE_DIR || path2.join(process.env.HOME || "", ".claude"))}" 2>/dev/null`, { encoding: "utf-8" }).trim().split(/\s+/)[0];
+      const projSize = execSync(`du -sh "${PROJECTS_DIR}" 2>/dev/null`, { encoding: "utf-8" }).trim().split(/\s+/)[0];
+      console.log("Storage:");
+      console.log(`  Total:         ${totalSize}`);
+      console.log(`  Projects:      ${projSize}`);
+    } catch {
+    }
+  });
+  session.command("clean").description("Delete session JSONL files older than N days").option("-d, --days <n>", "Delete files older than this many days", "30").option("--dry-run", "Show what would be deleted without deleting").action((opts) => {
+    const days = parseInt(opts.days, 10);
+    const cutoffMs = Date.now() - days * 24 * 60 * 60 * 1e3;
+    let deleted = 0;
+    let freed = 0;
+    const walk = (dir) => {
+      let entries;
+      try {
+        entries = fs2.readdirSync(dir, { withFileTypes: true });
+      } catch {
+        return;
+      }
+      for (const entry of entries) {
+        const fullPath = path2.join(dir, entry.name);
+        if (entry.isDirectory()) {
+          walk(fullPath);
+        } else if (entry.name.endsWith(".jsonl")) {
+          try {
+            const stat = fs2.statSync(fullPath);
+            if (stat.mtimeMs < cutoffMs) {
+              const size = stat.size;
+              if (opts.dryRun) {
+                console.log(`[dry-run] would delete: ${fullPath}  (${Math.floor(size / 1024)}KB)`);
+              } else {
+                fs2.unlinkSync(fullPath);
+                console.log(`Deleted: ${fullPath}`);
+              }
+              deleted++;
+              freed += size;
+            }
+          } catch {
+          }
+        }
+      }
+    };
+    walk(PROJECTS_DIR);
+    console.log("");
+    const verb = opts.dryRun ? "Would delete" : "Deleted";
+    console.log(`${verb} ${deleted} file(s) (~${Math.floor(freed / 1024)}KB freed)`);
+  });
+  return session;
+}
+
+// src/index.ts
+var program = new Command4();
+program.name("cc-hub").description("Manage Claude CLI profiles, hooks, and sessions").version("1.0.0");
+program.addCommand(profileCommand());
+program.addCommand(useCommand());
+program.addCommand(runCommand());
+program.addCommand(hooksCommand());
+program.addCommand(sessionCommand());
+program.parse();

package/package.json

@@ -0,0 +1,42 @@
+{
+  "name": "cc-hub-cli",
+  "version": "1.0.0",
+  "description": "Manage Claude CLI profiles, hooks, and sessions",
+  "type": "module",
+  "bin": {
+    "cc-hub": "./dist/index.js"
+  },
+  "scripts": {
+    "build": "tsup",
+    "dev": "tsup --watch",
+    "start": "node dist/index.js",
+    "prepublishOnly": "npm run build"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/sherocktong/cc-hub.git"
+  },
+  "keywords": [
+    "claude",
+    "cli",
+    "profiles",
+    "hooks",
+    "sessions",
+    "anthropic"
+  ],
+  "dependencies": {
+    "@anthropic-ai/sdk": "^0.39.0",
+    "commander": "^13.1.0"
+  },
+  "devDependencies": {
+    "tsup": "^8.4.0",
+    "typescript": "^5.7.0"
+  },
+  "engines": {
+    "node": ">=18"
+  },
+  "files": [
+    "dist"
+  ],
+  "license": "MIT"
+}