@promptctl/cc-candybar 1.42.1 → 1.43.0

package/src/help-text.ts

@@ -1,90 +0,0 @@
-import { DISCLOSURE_GLYPH_CLOSED } from "./config/disclosure";
-import { HELP_GLYPH_CLOSED } from "./config/help";
-import { NODE_FLAGS } from "./cli-flags";
-
-// [LAW:effects-at-boundaries] Pure data, no I/O — index.ts owns the console.log
-// effect. Kept as its own module so the text is importable (and testable) without
-// pulling in index.ts's top-level `main()` call.
-// [LAW:one-source-of-truth] The disclosure glyph comes from config/disclosure.ts
-// (the same constant the theme/look picker itself renders with), so this text
-// can't drift from what a user actually sees on the bar.
-// [LAW:one-source-of-truth] THE help corpus, as data. `--help` and the bar's
-// own `(?)` disclosures are two RENDERINGS of these arrays, never two copies of
-// the sentences: a `(?)` segment's template IS one of these strings, and the
-// paragraphs below interpolate the same values. A help sentence typed into a
-// segment template — where nothing would ever notice it drifting from the CLI's
-// wording — is the defect this shape exists to make unrepresentable.
-//
-// [LAW:representation] One line is one CELL on the bar, so each is a complete
-// thought that stands alone and each stays short: `(?)` bodies drop below their
-// row, and a body that overflows `term.cols` wraps into more rows than the fact
-// it explains is worth. Every line leads with the glyph it explains, so the
-// reader matches text to affordance by shape rather than by reading order.
-export const EDIT_MODE_HELP = [
-  "+ inserts here",
-  "- removes the one left of it",
-  "↺ undoes edits",
-] as const;
-
-export const PERSIST_HELP = [
-  "☐ this session only",
-  "☑ default for every session",
-] as const;
-
-export const HELP_TEXT = `
-cc-candybar - Beautiful powerline statusline for Claude Code
-
-Usage: cc-candybar [options]
-
-Standalone Commands:
-  ${NODE_FLAGS.help.join(", ").padEnd(25)}Show this help
-  ${NODE_FLAGS.version.join(", ").padEnd(25)}Print the version of this runtime (cc-candybar <version>)
-
-Debugging:
-  CC_CANDYBAR_DEBUG=1      Enable debug logging for troubleshooting
-
-Configuration:
-  Layout and segment options are defined in .cc-candybar.json5 (place in your
-  project dir, cwd, or ~/.config/cc-candybar/config.json5). Use CC_CANDYBAR_CONFIG
-  to point at a specific file. See the default config for all available options:
-    node dist/index.mjs debug --project-dir . --cwd .
-
-  Every bar carries a settings menu, whatever your config says — no config
-  needed, and writing your own \`root\` cannot delete it. Click
-  ☰ ${DISCLOSURE_GLYPH_CLOSED} on the bar for preset switching, edit mode, and a config menu
-  of clickable theme/look/style/wrap/padding controls. The \`persist?\`
-  checkbox there chooses where a change lands: ${PERSIST_HELP.join(", ")}.
-
-  Anywhere the bar shows ${HELP_GLYPH_CLOSED}, clicking it reveals these same instructions
-  in place. In edit mode: ${EDIT_MODE_HELP.join(", ")}.
-
-Subcommands:
-  install                  One-shot setup: stages the runtime (native render
-                           binary + dist bundle) at a stable path, creates the
-                           URL handler app + cc-candybar:// scheme (macOS), and
-                           writes the staged entry as the statusLine command in
-                           ~/.claude/settings.json. Re-run to update.
-  install-url-handler      Just stage the runtime and create + register the URL
-                           handler app (macOS only).
-  url-handle URL           Internal — invoked by the URL handler app on
-                           cmd-click. Parses cc-candybar://<verb>/<value> and
-                           dispatches (currently: copy to clipboard).
-  daemon-stats [--json]    Query the running daemon for runtime stats:
-                           uptime, RSS, cache hit rates, watcher count,
-                           request totals. Does not spawn a daemon.
-
-Config tooling:
-  check [config-file]      Validate a config on the full render pipeline (parse
-                           → merge → validate → register → render) with no
-                           daemon. With no path, checks the same file the daemon
-                           would load from here. Exit 0 clean (warnings on
-                           stderr), 1 invalid, 2 unreadable. "lint" is an alias.
-  schema                   Print the JSON Schema for the config file shape
-                           (.cc-candybar.json5). Point an editor's $schema at it
-                           for autocomplete + structural validation.
-  vars [--json]            Declared variables: source kind, value, last error.
-  segments [--json]        Segment templates and their last rendered output.
-  config [--json]          The effective merged config. (All three query the
-                           running daemon; none spawn one.)
-
-`;

package/src/index.ts

@@ -1,210 +0,0 @@
-#!/usr/bin/env node
-
-import type { ClaudeHookData } from "./utils/claude";
-
-import process from "node:process";
-import { json } from "node:stream/consumers";
-import { debug } from "./utils/logger";
-import { runInstall, runInstallUrlHandler, runUrlHandle } from "./install";
-import { runDaemon } from "./daemon/server";
-import { tryRenderViaDaemon } from "./daemon/client";
-import { runDaemonStats } from "./daemon/client-stats";
-import { runDebug } from "./daemon/client-debug";
-import { isDebugWhat } from "./daemon/debug-types";
-import { runSchema } from "./config/cli";
-import { runCheck } from "./check";
-import { obtainDaemonKick } from "./daemon/acquire";
-import { planOutcome } from "./render/outcome-plan";
-import { HELP_TEXT } from "./help-text";
-import { NODE_FLAGS } from "./cli-flags";
-import { PACKAGE_VERSION } from "./version";
-
-// Read terminal width from the live shell context (no subprocess). Returns
-// undefined when nothing reliable is available; the daemon falls back to its
-// own pure lookup chain in that case. Always-COLUMNS-first because Bash
-// exports it on resize and Claude Code propagates it to hook commands.
-// stderr (not stdout) is the TTY-side fallback: when invoked as a Claude
-// statusline hook, stdin is the hook JSON pipe and stdout is the captured
-// statusline pipe, leaving stderr as the only stream still attached to the
-// parent terminal. Mirrors the Rust client's TIOCGWINSZ-on-STDERR_FILENO.
-function detectTermCols(): number | undefined {
-  const env = process.env.COLUMNS;
-  if (env) {
-    const n = parseInt(env, 10);
-    if (!isNaN(n) && n > 0) return n;
-  }
-  const cols = process.stderr.columns;
-  if (cols && cols > 0) return cols;
-  return undefined;
-}
-
-// The env vars an SSH login shell inherits from sshd. Any one of them present
-// and non-empty means this session arrived over the network.
-//
-// [LAW:one-source-of-truth] This vocabulary is mirrored by the Rust client
-// (rust-client/src/main.rs) and diffed by scripts/check-protocol.mjs, which
-// anchors on the declaration below — keep it a named const holding string
-// literals, or repoint the CHECKS row in the same commit. Both runtimes must
-// agree on what "SSH" means or the fast path and the fallback path would
-// disagree about the same session.
-//
-// All three are checked, not just SSH_CONNECTION: SSH_CLIENT is what older
-// sshd builds (and the user's git-taculous zsh theme) key on, and SSH_TTY is
-// the one that survives some `sudo` env_keep policies. Extra names can only
-// widen recall of a fact that is otherwise reported as a plain `false`.
-const SSH_ENV_VARS = ["SSH_CONNECTION", "SSH_CLIENT", "SSH_TTY"] as const;
-
-const hasFlag = (flags: readonly string[]): boolean =>
-  flags.some((f) => process.argv.includes(f));
-
-// [LAW:dataflow-not-control-flow] A fold over the vocabulary, not a chain of
-// ifs — adding a name is a data edit.
-//
-// Unlike detectTermCols this is TOTAL: the client reads its own environment, so
-// "no SSH var set" is the affirmative answer "local", never a failure to
-// determine. It therefore always reports, and the daemon reads an ABSENT `ssh`
-// hint as "this client is too old to answer" rather than as "local".
-function detectSsh(): boolean {
-  return SSH_ENV_VARS.some((name) => (process.env[name] ?? "") !== "");
-}
-
-function showHelpText(): void {
-  console.log(HELP_TEXT);
-}
-
-async function main(): Promise<void> {
-  try {
-    if (hasFlag(NODE_FLAGS.help)) {
-      showHelpText();
-      process.exit(0);
-    }
-    // [LAW:one-type-per-behavior] Answers "what is THIS binary" from the baked
-    // stamp alone — never a daemon probe, which would fail exactly when the
-    // flag is most needed (no working daemon). Daemon skew is the stats
-    // snapshot's `version` field.
-    if (hasFlag(NODE_FLAGS.version)) {
-      console.log(`cc-candybar ${PACKAGE_VERSION}`);
-      process.exit(0);
-    }
-
-    // [LAW:dataflow-not-control-flow] Subcommand dispatch is data: argv[2]
-    // selects the handler. Each handler short-circuits via process.exit().
-    // Default fallthrough = the existing stdin-driven render flow.
-    const subcommand = process.argv[2];
-    if (subcommand === "install") {
-      await runInstall(process.argv.slice(3));
-      process.exit(0);
-    }
-    if (subcommand === "install-url-handler") {
-      runInstallUrlHandler();
-      process.exit(0);
-    }
-    if (subcommand === "url-handle") {
-      await runUrlHandle(process.argv[3]);
-      return;
-    }
-    if (subcommand === "daemon") {
-      runDaemon();
-      return; // daemon owns its own lifecycle
-    }
-    if (subcommand === "daemon-stats") {
-      await runDaemonStats(process.argv.slice(3));
-      process.exit(0);
-    }
-    // [LAW:one-type-per-behavior] `lint` is an alias of `check` — one config
-    // verdict, one pipeline, one exit-code contract (0/1/2). check subsumes the
-    // old lint (same loader, plus register + render coverage).
-    if (subcommand === "check" || subcommand === "lint") {
-      runCheck(process.argv.slice(3)); // owns its own exit code (0/1/2)
-      return;
-    }
-    if (subcommand === "schema") {
-      runSchema(); // owns its own exit code
-      return;
-    }
-    // [LAW:dataflow-not-control-flow] vars/segments/config are ONE handler
-    // parameterized by `what` — the subcommand name IS the DebugWhat. The guard
-    // is the canonical list (debug-types), so a new debug projection is reachable
-    // here with no second-site edit.
-    if (isDebugWhat(subcommand)) {
-      await runDebug(subcommand, process.argv.slice(3));
-      process.exit(0);
-    }
-
-    if (process.stdin.isTTY === true) {
-      console.error(`Error: This tool requires input from Claude Code
-
-cc-candybar is designed to be used as a Claude Code statusLine command.
-It reads hook data from stdin and outputs formatted statusline.
-
-Add to ~/.claude/settings.json:
-{
-  "statusLine": {
-    "type": "command",
-    "command": "cc-candybar --style=powerline"
-  }
-}
-
-Run with --help for more options.
-
-To test output manually:
-echo '{"session_id":"test-session","workspace":{"project_dir":"/path/to/project"},"model":{"id":"claude-sonnet-4-5","display_name":"Claude"}}' | cc-candybar --style=powerline`);
-      process.exit(1);
-    }
-
-    debug(`Working directory: ${process.cwd()}`);
-    debug(`Process args:`, process.argv);
-
-    const hookData = (await json(process.stdin)) as ClaudeHookData;
-    debug(`Received hook data:`, JSON.stringify(hookData, null, 2));
-
-    if (!hookData) {
-      console.error("Error: No input data received from stdin");
-      showHelpText();
-      process.exit(1);
-    }
-
-    // [LAW:one-source-of-truth] The daemon is the *only* renderer. The CLI is
-    // a dumb relay: forward stdin to the daemon, print whatever comes back.
-    // There is no inline render path — two renderers would drift (the CLI has
-    // no shared gitService/usageProvider, no per-session state, no warm
-    // caches). On daemon miss we spawn detached and emit empty output; the
-    // next status-line refresh hits the warm daemon and renders for real.
-    //
-    // [LAW:single-enforcer] Client hints are captured here, in the user's
-    // shell environment, then trusted by the daemon. The daemon's own env
-    // reflects whichever shell launched it minutes/hours ago, so it can
-    // measure neither the active terminal nor whether THIS session came in
-    // over SSH — only the live client can. One daemon serves a local session
-    // and an SSH session at the same time, so the answer genuinely differs per
-    // request.
-    const outcome = await tryRenderViaDaemon(
-      hookData,
-      process.argv,
-      process.cwd(),
-      { termCols: detectTermCols(), ssh: detectSsh() },
-    );
-    // [LAW:types-are-the-program] Three variants, one per outcome kind. The
-    // "kick on every failure" pattern was the load-bearing half of the
-    // 452-corpse spiral (kz8.5) — kicking on `permanent` failures keeps
-    // respawning a daemon that will refuse the next request identically.
-    // [LAW:dataflow-not-control-flow] planOutcome maps each variant to a
-    // plan value (output, kick, debug); the side effects below run against
-    // the plan in fixed order. Variability lives in the data.
-    const plan = planOutcome(outcome);
-    if (plan.debug !== null) {
-      debug(plan.debug);
-    }
-    if (plan.kick) {
-      obtainDaemonKick();
-    }
-    process.stdout.write(plan.output);
-    process.exit(0);
-  } catch (error) {
-    const errorMessage = error instanceof Error ? error.message : String(error);
-    console.error("Error generating statusline:", errorMessage);
-    process.exit(1);
-  }
-}
-
-main();

package/src/install/currency.ts

@@ -1,197 +0,0 @@
-// Is the runtime `install` just staged the newest published release? pnpm
-// resolves `@latest` through its dlx cache and its release-age gate
-// (`minimumReleaseAge`), either of which can hand back an older release with
-// no error — so `pnpm dlx @promptctl/cc-candybar@latest install` can stage a
-// version several releases behind and report success. This module answers the
-// currency question as data: a strict version parser at the border, the
-// registry lookup as an `Outcome`, one total fold into a `Currency`, and one
-// formatter that describes the report for `runInstall` to perform.
-
-import { ABSENT, failed, type Outcome } from "../utils/outcome";
-
-// [LAW:types-are-the-program] A release version is exactly MAJOR.MINOR.PATCH.
-// semantic-release on `main` mints nothing else, and the ordering the currency
-// verdict needs is total only over that shape — so the parser refuses anything
-// else rather than admitting a prerelease it could not order.
-export type Version = readonly [major: number, minor: number, patch: number];
-
-const RELEASE_VERSION = /^(0|[1-9]\d*)\.(0|[1-9]\d*)\.(0|[1-9]\d*)$/;
-
-// A parse either produces a value or fails with a reason; "absent" is not a
-// shape text can have.
-type Parsed<T> = Exclude<Outcome<T>, { kind: "absent" }>;
-
-// [LAW:parse-dont-validate] The one crossing from text to `Version`. Both the
-// baked stamp and the registry's dist-tag pass through here; downstream code
-// takes `Version` and never re-checks the shape. The failure is typed, not
-// thrown: on either side it flows into the `unchecked` verdict, so the
-// advisory check can never take the install down with it.
-export function parseReleaseVersion(text: string): Parsed<Version> {
-  const m = RELEASE_VERSION.exec(text);
-  return m
-    ? { kind: "ok", value: [Number(m[1]), Number(m[2]), Number(m[3])] }
-    : {
-        kind: "failed",
-        reason: `"${text}" is not a release version (expected MAJOR.MINOR.PATCH)`,
-      };
-}
-
-export function formatVersion(v: Version): string {
-  return v.join(".");
-}
-
-// Lexicographic over the triple: the first differing component decides.
-function compareVersions(
-  [aMajor, aMinor, aPatch]: Version,
-  [bMajor, bMinor, bPatch]: Version,
-): number {
-  return aMajor - bMajor || aMinor - bMinor || aPatch - bPatch;
-}
-
-export const REGISTRY_URL = "https://registry.npmjs.org";
-
-// The check rides at the end of an install; it may not hang one. A registry
-// that answers slower than this is reported as unreachable, not waited on.
-export const REGISTRY_TIMEOUT_MS = 5_000;
-
-// [LAW:effects-at-boundaries] The one network effect in the install path. It
-// takes `fetch` as a parameter so the pure core above and the tests never
-// touch the wire; the caller hands in the global. Every way the lookup can
-// fail to answer — refused, timed out, non-2xx, unparseable body, dist-tag not
-// a release — collapses to `failed` with its reason preserved, and a registry
-// that lists no `latest` tag at all is `absent`. [LAW:no-silent-failure] None
-// of those is ever reported as "current".
-export async function fetchLatestVersion(
-  packageName: string,
-  fetchImpl: typeof fetch,
-): Promise<Outcome<Version>> {
-  const url = `${REGISTRY_URL}/-/package/${encodeURIComponent(packageName)}/dist-tags`;
-  try {
-    const res = await fetchImpl(url, {
-      signal: AbortSignal.timeout(REGISTRY_TIMEOUT_MS),
-    });
-    if (!res.ok) {
-      return failed(`registry responded ${res.status} for ${url}`);
-    }
-    const tags = (await res.json()) as { latest?: unknown };
-    if (typeof tags.latest !== "string") {
-      return ABSENT;
-    }
-    return parseReleaseVersion(tags.latest);
-  } catch (err) {
-    return failed(err instanceof Error ? err.message : String(err));
-  }
-}
-
-// [LAW:types-are-the-program] The verdict. `unchecked` is its own arm rather
-// than a `current` with a flag: an install that could not compare has no
-// currency, and no consumer may read it as having one. It carries the stamp
-// as text because the stamp itself may be what failed to parse.
-export type Currency =
-  | { readonly kind: "current"; readonly installed: Version }
-  | {
-      readonly kind: "stale";
-      readonly installed: Version;
-      readonly latest: Version;
-    }
-  | {
-      readonly kind: "ahead";
-      readonly installed: Version;
-      readonly latest: Version;
-    }
-  | {
-      readonly kind: "unchecked";
-      readonly installed: string;
-      readonly reason: string;
-    };
-
-// [LAW:dataflow-not-control-flow] One total fold: the stamp, the lookup
-// outcome, and the version ordering all flow in as values, and every
-// combination lands in exactly one arm.
-export function assessCurrency(
-  stamp: string,
-  latest: Outcome<Version>,
-): Currency {
-  const installed = parseReleaseVersion(stamp);
-  if (installed.kind === "failed") {
-    return { kind: "unchecked", installed: stamp, reason: installed.reason };
-  }
-  switch (latest.kind) {
-    case "failed":
-      return { kind: "unchecked", installed: stamp, reason: latest.reason };
-    case "absent":
-      return {
-        kind: "unchecked",
-        installed: stamp,
-        reason: "the registry lists no `latest` dist-tag",
-      };
-    case "ok": {
-      const order = compareVersions(installed.value, latest.value);
-      if (order < 0) {
-        return {
-          kind: "stale",
-          installed: installed.value,
-          latest: latest.value,
-        };
-      }
-      if (order > 0) {
-        return {
-          kind: "ahead",
-          installed: installed.value,
-          latest: latest.value,
-        };
-      }
-      return { kind: "current", installed: installed.value };
-    }
-  }
-}
-
-// A description of the report, not the report itself: `runInstall` owns the
-// write. Warnings go to stderr, confirmations to stdout — the CLI's stream
-// contract, so a scripted install can separate the two.
-export interface CurrencyReport {
-  readonly stream: "stdout" | "stderr";
-  readonly text: string;
-}
-
-// [LAW:no-silent-failure] The stale arm names the cause and the exact command
-// that gets the current release now; the unchecked arm says the check was
-// skipped and why, and never implies the install is current.
-export function currencyReport(
-  packageName: string,
-  currency: Currency,
-): CurrencyReport {
-  switch (currency.kind) {
-    case "current":
-      return {
-        stream: "stdout",
-        text: `✓ cc-candybar ${formatVersion(currency.installed)} is the latest release.\n`,
-      };
-    case "ahead":
-      return {
-        stream: "stdout",
-        text:
-          `cc-candybar ${formatVersion(currency.installed)} is newer than the registry's latest release ` +
-          `(${formatVersion(currency.latest)}): an unpublished build.\n`,
-      };
-    case "stale": {
-      const latest = formatVersion(currency.latest);
-      return {
-        stream: "stderr",
-        text:
-          `⚠ cc-candybar ${formatVersion(currency.installed)} was staged, but the latest release is ${latest}.\n` +
-          `  pnpm's release-age gate (minimumReleaseAge) and its dlx cache can both\n` +
-          `  resolve \`@latest\` to an older release without saying so.\n` +
-          `  To install ${latest} now, name it explicitly:\n` +
-          `    pnpm dlx ${packageName}@${latest} install\n`,
-      };
-    }
-    case "unchecked":
-      return {
-        stream: "stderr",
-        text:
-          `⚠ Could not check for a cc-candybar release newer than ${currency.installed} ` +
-          `(${currency.reason}); the registry check was skipped.\n`,
-      };
-  }
-}