harnery 0.0.1 → 0.2.0

package/src/commands/config-get.ts

@@ -0,0 +1,161 @@
+import { existsSync, readFileSync } from "node:fs";
+import { extname, resolve } from "node:path";
+import type { Command } from "commander";
+import yaml from "js-yaml";
+import type { EmitContext } from "../commander.ts";
+
+/**
+ * `config-get <file> <key>`: extract one value from a JSON or YAML config
+ * file by dotted-path. Avoids reading the whole file or shelling out to jq
+ * (which doesn't stream well through session-tee). Bracket notation supported
+ * for hyphenated keys and arrays: `compilerOptions.paths["@/*"][0]`.
+ */
+
+interface ConfigGetOpts {
+  json?: boolean;
+  raw?: boolean;
+}
+
+interface ConfigGetResult {
+  file: string;
+  format: string;
+  key: string;
+  value: unknown;
+  type: string;
+  found: boolean;
+}
+
+export function registerConfigGetCommand(program: Command, emit: EmitContext): void {
+  program
+    .command("config-get <file> <key>")
+    .description(
+      "Extract a single value from a JSON/YAML config file by dotted-path. " +
+        "Bracket notation supported: `config-get tsconfig.json compilerOptions.paths`.",
+    )
+    .option("--json", "Structured JSON envelope {file, format, key, value, type, found}")
+    .option("--raw", "Print raw string value (no JSON encoding wrapper)")
+    .action(async (file: string, key: string, opts: ConfigGetOpts) => {
+      try {
+        const result = await runConfigGet(file, key);
+        if (opts.json) {
+          emit.config({ format: "json" });
+          emit.data(result);
+          return;
+        }
+        if (!result.found) {
+          emit.error({ code: "key_not_found", message: `key "${key}" not found in ${file}` });
+          process.exit(1);
+        }
+        emit.text(`${renderValue(result.value)}\n`);
+      } catch (err) {
+        emit.error({ code: "config_get_failed", message: (err as Error).message });
+        process.exit(1);
+      }
+    });
+}
+
+async function runConfigGet(file: string, key: string): Promise<ConfigGetResult> {
+  const absPath = resolve(file);
+  if (!existsSync(absPath)) throw new Error(`no such file: ${file}`);
+  const content = readFileSync(absPath, "utf8");
+  const ext = extname(absPath).toLowerCase();
+
+  let format: string;
+  let parsed: unknown;
+
+  if (ext === ".json") {
+    format = "json";
+    try {
+      parsed = JSON.parse(content);
+    } catch (err) {
+      throw new Error(`json parse failed: ${(err as Error).message}`);
+    }
+  } else if (ext === ".yaml" || ext === ".yml") {
+    format = "yaml";
+    try {
+      parsed = yaml.load(content);
+    } catch (err) {
+      throw new Error(`yaml parse failed: ${(err as Error).message}`);
+    }
+  } else {
+    throw new Error(
+      `unsupported file type: ${ext || "(no extension)"} (supported: .json, .yaml, .yml)`,
+    );
+  }
+
+  const parts = parseDottedPath(key);
+  let cur: unknown = parsed;
+  let found = true;
+
+  for (const p of parts) {
+    if (cur == null || typeof cur !== "object") {
+      found = false;
+      cur = undefined;
+      break;
+    }
+    const obj = cur as Record<string, unknown>;
+    if (!(p in obj)) {
+      found = false;
+      cur = undefined;
+      break;
+    }
+    cur = obj[p];
+  }
+
+  const type =
+    cur === null
+      ? "null"
+      : Array.isArray(cur)
+        ? "array"
+        : cur === undefined
+          ? "undefined"
+          : typeof cur;
+
+  return {
+    file,
+    format,
+    key,
+    value: cur,
+    type,
+    found,
+  };
+}
+
+function parseDottedPath(path: string): string[] {
+  const parts: string[] = [];
+  let i = 0;
+  while (i < path.length) {
+    if (path[i] === ".") {
+      i++;
+      continue;
+    }
+    if (path[i] === "[") {
+      const end = path.indexOf("]", i);
+      if (end < 0) throw new Error(`unmatched [ in key: ${path}`);
+      let inner = path.slice(i + 1, end);
+      if (
+        (inner.startsWith('"') && inner.endsWith('"')) ||
+        (inner.startsWith("'") && inner.endsWith("'"))
+      ) {
+        inner = inner.slice(1, -1);
+      }
+      parts.push(inner);
+      i = end + 1;
+      continue;
+    }
+    let end = i;
+    while (end < path.length && path[end] !== "." && path[end] !== "[") end++;
+    parts.push(path.slice(i, end));
+    i = end;
+  }
+  return parts;
+}
+
+function renderValue(value: unknown): string {
+  if (value === undefined) return "";
+  if (typeof value === "string") return value;
+  if (value === null || typeof value === "boolean" || typeof value === "number") {
+    return String(value);
+  }
+  return JSON.stringify(value, null, 2);
+}

package/src/commands/context.ts

@@ -0,0 +1,209 @@
+import type { Command } from "commander";
+import type { EmitContext, HarneryProgramContext } from "../commander.ts";
+import {
+  buildContext,
+  type ContextReport,
+  DEFAULT_SECTIONS,
+  OPT_IN_SECTIONS,
+  type SectionName,
+} from "../lib/context/index.ts";
+
+/**
+ * `harn context`: one-shot orientation snapshot.
+ *
+ * Aggregates self / time / repo / commits / submodules / peers (default) plus
+ * opt-in services. Useful at session start, post-compaction, or before
+ * dispatching subagents. Fail-open per section.
+ */
+export function registerContextCommand(
+  program: Command,
+  emit: EmitContext,
+  context?: HarneryProgramContext,
+): void {
+  program
+    .command("context")
+    .description(
+      `One-shot orientation snapshot: self, repo, submodules, peers, recent commits. Default sections: ${DEFAULT_SECTIONS.join(" / ")}. Opt-in: ${OPT_IN_SECTIONS.join(" / ")}.`,
+    )
+    .option(
+      "--section <name>",
+      `Limit to specific sections (comma-list or repeated; valid: ${[...DEFAULT_SECTIONS, ...OPT_IN_SECTIONS].join(", ")})`,
+      collectSections,
+      [] as SectionName[],
+    )
+    .option(
+      "--include <name>",
+      "Add an opt-in section (e.g. services)",
+      collectSections,
+      [] as SectionName[],
+    )
+    .option("--show-clean", "Don't hide clean submodules")
+    .option("--json", "Structured JSON envelope")
+    .action(
+      async (opts: {
+        section: SectionName[];
+        include: SectionName[];
+        showClean?: boolean;
+        json?: boolean;
+      }) => {
+        try {
+          const sections = opts.section.length > 0 ? opts.section : DEFAULT_SECTIONS;
+          const report = await buildContext({
+            sections,
+            include: opts.include,
+            showClean: opts.showClean,
+            repoRoot: context?.repoRoot,
+            submodules: context?.submodules,
+          });
+          if (opts.json) {
+            emit.config({ format: "json" });
+            emit.data(report);
+            return;
+          }
+          emit.text(`${renderReport(report)}\n`);
+        } catch (err) {
+          const msg = err instanceof Error ? err.message : String(err);
+          emit.error({ code: "context_failed", message: msg });
+          process.exit(1);
+        }
+      },
+    );
+}
+
+function collectSections(value: string, prev: SectionName[]): SectionName[] {
+  const all: SectionName[] = [...DEFAULT_SECTIONS, ...OPT_IN_SECTIONS];
+  const out = [...prev];
+  for (const tok of value
+    .split(",")
+    .map((s) => s.trim())
+    .filter(Boolean)) {
+    if (!all.includes(tok as SectionName)) {
+      throw new Error(`unknown section "${tok}". Valid: ${all.join(", ")}`);
+    }
+    if (!out.includes(tok as SectionName)) out.push(tok as SectionName);
+  }
+  return out;
+}
+
+// ─── TTY rendering ─────────────────────────────────────────────────────────
+
+function renderReport(r: ContextReport): string {
+  const lines: string[] = [];
+  if (r.self) lines.push(...renderSelf(r.self));
+  if (r.time) lines.push(...renderTime(r.time));
+  if (r.repo) lines.push(...renderRepo(r.repo));
+  if (r.commits) lines.push(...renderCommits(r.commits));
+  if (r.submodules) lines.push(...renderSubmodules(r.submodules));
+  if (r.peers) lines.push(...renderPeers(r.peers));
+  if (r.services) lines.push(...renderServices(r.services));
+  lines.push("");
+  lines.push(`(elapsed: ${r.meta.elapsed_ms}ms)`);
+  return lines.join("\n");
+}
+
+function section(header: string, body: string[]): string[] {
+  return ["", `── ${header} ──`, ...body];
+}
+
+function renderSelf(s: NonNullable<ContextReport["self"]>): string[] {
+  if ("error" in s) return section("self", [`  (unavailable: ${s.error})`]);
+  const body: string[] = [];
+  body.push(
+    `  agent-${s.name ?? "?"}  (${formatAge(s.session_age_secs)} old, owner=${s.instance_id.slice(0, 8)}…)`,
+  );
+  if (s.task) body.push(`  task:    "${s.task}"`);
+  if (s.last_tool) {
+    const target = s.last_tool_target ? `  ${truncate(s.last_tool_target, 80)}` : "";
+    body.push(`  last:    ${s.last_tool}${target}`);
+  }
+  if (s.files_held.length > 0) {
+    body.push(`  holds ${s.files_held.length} file(s):`);
+    for (const f of s.files_held.slice(0, 5)) body.push(`    ${f}`);
+    if (s.files_held.length > 5) body.push(`    +${s.files_held.length - 5} more`);
+  } else {
+    body.push("  files:   none held");
+  }
+  return section("self", body);
+}
+
+function renderTime(t: NonNullable<ContextReport["time"]>): string[] {
+  return section("time", [`  ${t.chicago}  (UTC: ${t.utc})`]);
+}
+
+function renderRepo(r: NonNullable<ContextReport["repo"]>): string[] {
+  if ("error" in r) return section("repo", [`  (unavailable: ${r.error})`]);
+  const parts: string[] = [];
+  const aheadBehind =
+    r.ahead > 0 || r.behind > 0 ? ` (ahead ${r.ahead}, behind ${r.behind} vs origin)` : "";
+  parts.push(`  cwd:     ${r.cwd}`);
+  parts.push(`  branch:  ${r.branch}${aheadBehind}`);
+  const dirtyBits: string[] = [];
+  if (r.staged) dirtyBits.push(`${r.staged} staged`);
+  if (r.modified) dirtyBits.push(`${r.modified} modified`);
+  if (r.untracked) dirtyBits.push(`${r.untracked} untracked`);
+  parts.push(`  status:  ${dirtyBits.length ? dirtyBits.join(", ") : "clean"}`);
+  return section("repo", parts);
+}
+
+function renderCommits(c: NonNullable<ContextReport["commits"]>): string[] {
+  if ("error" in c) return section("commits", [`  (unavailable: ${c.error})`]);
+  if (c.rows.length === 0) return section("commits", ["  (none)"]);
+  return section(
+    "commits (last 3)",
+    c.rows.map((row) => `  ${row.sha}  ${truncate(row.subject, 80)}`),
+  );
+}
+
+function renderSubmodules(s: NonNullable<ContextReport["submodules"]>): string[] {
+  if ("error" in s) return section("submodules", [`  (unavailable: ${s.error})`]);
+  if (s.rows.length === 0) {
+    const tail = s.clean_omitted > 0 ? ` (${s.clean_omitted} clean omitted)` : "";
+    return section("submodules", [`  all clean${tail}`]);
+  }
+  const lines = s.rows.map((sm) => {
+    const aheadBehind = sm.ahead > 0 || sm.behind > 0 ? ` ±${sm.ahead}/${sm.behind}` : "";
+    const dirty = sm.dirty ? ` (${sm.modifiedFiles}m+${sm.untrackedFiles}u)` : "";
+    return `  ${sm.name.padEnd(28)} ${sm.branch}${aheadBehind}${dirty}`;
+  });
+  const tail = s.clean_omitted > 0 ? [`  (+${s.clean_omitted} clean omitted)`] : [];
+  return section("submodules", [...lines, ...tail]);
+}
+
+function renderPeers(p: NonNullable<ContextReport["peers"]>): string[] {
+  if ("error" in p) return section("peers", [`  (unavailable: ${p.error})`]);
+  if (p.rows.length === 0) return section("peers", ["  (none active)"]);
+  const lines = p.rows.map((peer) => {
+    const taskBit = peer.task ? ` "${truncate(peer.task, 40)}"` : "";
+    const filesBit = peer.files > 0 ? `${peer.files}f` : "0f";
+    const lastBit = peer.last_tool ? `, last: ${peer.last_tool}` : "";
+    return `  agent-${peer.name.padEnd(12)}${taskBit}  (${peer.age_min}m old, ${filesBit}${lastBit})`;
+  });
+  return section("peers", lines);
+}
+
+function renderServices(s: NonNullable<ContextReport["services"]>): string[] {
+  if ("error" in s) return section("services", [`  (unavailable: ${s.error})`]);
+  if (s.docker_compose.length === 0) return section("services", ["  (no compose project running)"]);
+  const lines = s.docker_compose.map((sv) => `  ${sv.service.padEnd(20)} ${sv.status}`);
+  return section("services (docker compose)", lines);
+}
+
+// ─── Format helpers ────────────────────────────────────────────────────────
+
+function formatAge(secs: number): string {
+  if (secs < 60) return `${secs}s`;
+  if (secs < 3600) return `${Math.floor(secs / 60)}m`;
+  if (secs < 86400) {
+    const h = Math.floor(secs / 3600);
+    const m = Math.floor((secs % 3600) / 60);
+    return `${h}h ${m}m`;
+  }
+  const d = Math.floor(secs / 86400);
+  const h = Math.floor((secs % 86400) / 3600);
+  return `${d}d ${h}h`;
+}
+
+function truncate(s: string, n: number): string {
+  if (s.length <= n) return s;
+  return `${s.slice(0, n - 1)}…`;
+}

package/src/commands/cookies.ts

@@ -0,0 +1,198 @@
+import { homedir } from "node:os";
+import { resolve } from "node:path";
+import type { Command } from "commander";
+import type { EmitContext } from "../commander.ts";
+import { type Cookie, CookieJar } from "../lib/cookies/index.ts";
+
+/**
+ * `cookies`: manage the local browser cookie store.
+ *
+ * Default store path: `~/.cache/harnery/cookies.json`. Override with
+ * `--store <path>` if you need a separate jar (e.g., one per environment).
+ * Format is CDP-native (compatible with Playwright/agent-browser).
+ */
+
+const DEFAULT_STORE = resolve(homedir(), ".cache", "harnery", "cookies.json");
+
+interface CommonOpts {
+  store?: string;
+  json?: boolean;
+}
+
+function jarFrom(opts: CommonOpts): CookieJar {
+  return new CookieJar({
+    path: opts.store ?? DEFAULT_STORE,
+    source: "bp-cookies",
+  });
+}
+
+// Module-scoped emit assigned by registerCookiesCommand; the module-level
+// helpers below close over this so the Commander .action callbacks stay
+// concise. Safe because the command tree is registered once at startup.
+let emit: EmitContext;
+
+export function registerCookiesCommand(program: Command, emitParam: EmitContext): void {
+  emit = emitParam;
+  const cmd = program
+    .command("cookies")
+    .description(
+      `Manage the shared browser cookie store (default: ${DEFAULT_STORE}). Format is CDP-native (compatible with Playwright/agent-browser).`,
+    )
+    .option("--store <path>", "Override store path");
+
+  cmd.action((opts: CommonOpts) => safe(() => runList(jarFrom(opts), {})));
+
+  cmd
+    .command("list")
+    .description("List cookies in the store, grouped by domain")
+    .option("--domain <domain>", "Filter by domain")
+    .option("--json", "Output as JSON")
+    .action((opts: CommonOpts & { domain?: string }) =>
+      safe(() => runList(jarFrom({ ...cmd.opts(), ...opts }), opts)),
+    );
+
+  cmd
+    .command("set <name> <value>")
+    .description("Set a cookie in the store (creates the file if missing)")
+    .requiredOption("--domain <domain>", "Cookie domain (e.g., .example.com)")
+    .option("--path <path>", "Cookie path", "/")
+    .option("--secure", "HTTPS only")
+    .option("--httpOnly", "Prevent JavaScript access")
+    .option("--sameSite <policy>", "SameSite policy: Strict | Lax | None")
+    .option("--expires <unix-seconds>", "Unix timestamp; omit for session cookie")
+    .action(
+      (
+        name: string,
+        value: string,
+        opts: CommonOpts & {
+          domain: string;
+          path: string;
+          secure?: boolean;
+          httpOnly?: boolean;
+          sameSite?: string;
+          expires?: string;
+        },
+      ) => safe(() => runSet(jarFrom({ ...cmd.opts(), ...opts }), name, value, opts)),
+    );
+
+  cmd
+    .command("clear")
+    .description("Remove cookies from the store")
+    .option("--domain <domain>", "Drop cookies matching a single domain")
+    .option("--all", "Wipe everything (cookies + origins)")
+    .action((opts: CommonOpts & { domain?: string; all?: boolean }) =>
+      safe(() => runClear(jarFrom({ ...cmd.opts(), ...opts }), opts)),
+    );
+
+  cmd
+    .command("header <url>")
+    .description("Print a Cookie: header value for the given URL (empty if no match)")
+    .action((url: string, opts: CommonOpts) =>
+      safe(() => {
+        const jar = jarFrom({ ...cmd.opts(), ...opts });
+        const out = jar.header(url);
+        if (out) emit.text(`${out}\n`);
+      }),
+    );
+
+  cmd
+    .command("import <file>")
+    .description("Merge cookies from a JSON file (CDP/agent-browser shape)")
+    .option("--replace", "Replace the entire store instead of merging")
+    .action((file: string, opts: CommonOpts & { replace?: boolean }) =>
+      safe(() => {
+        const jar = jarFrom({ ...cmd.opts(), ...opts });
+        const { count } = jar.import(file, opts);
+        emit.data({ ok: true, action: "import", count, file });
+      }),
+    );
+
+  cmd
+    .command("export <file>")
+    .description("Write the store to a file (for sharing with another tool)")
+    .action((file: string, opts: CommonOpts) =>
+      safe(() => {
+        const jar = jarFrom({ ...cmd.opts(), ...opts });
+        const { count } = jar.export(file);
+        emit.file(file, { cookies: count });
+      }),
+    );
+
+  cmd
+    .command("info")
+    .description("Show store path, size, cookie counts, and exporting tool")
+    .option("--json", "Output as JSON")
+    .action((opts: CommonOpts) => safe(() => runInfo(jarFrom({ ...cmd.opts(), ...opts }), opts)));
+}
+
+// ---------------------------------------------------------------------------
+// Subcommand handlers
+// ---------------------------------------------------------------------------
+
+function runList(jar: CookieJar, opts: { domain?: string; json?: boolean }): void {
+  if (opts.json) emit.config({ format: "json" });
+  const cookies = jar.list({ domain: opts.domain });
+  emit.rows(cookies as unknown as Record<string, unknown>[]);
+}
+
+function runSet(
+  jar: CookieJar,
+  name: string,
+  value: string,
+  opts: {
+    domain: string;
+    path: string;
+    secure?: boolean;
+    httpOnly?: boolean;
+    sameSite?: string;
+    expires?: string;
+  },
+): void {
+  const cookie: Cookie = {
+    name,
+    value,
+    domain: opts.domain,
+    path: opts.path,
+    expires: opts.expires ? Number.parseFloat(opts.expires) : -1,
+    httpOnly: opts.httpOnly ?? false,
+    secure: opts.secure ?? false,
+    session: !opts.expires,
+    size: name.length + value.length,
+  };
+  if (opts.sameSite) cookie.sameSite = opts.sameSite;
+  jar.set(cookie);
+  emit.data({ ok: true, action: "set", name, domain: opts.domain });
+}
+
+function runClear(jar: CookieJar, opts: { domain?: string; all?: boolean }): void {
+  if (!opts.domain && !opts.all) {
+    throw new Error("Specify --domain <domain> or --all");
+  }
+  const { before, after } = jar.clear(opts);
+  const removed = before - after;
+  emit.data({
+    ok: true,
+    action: "clear",
+    removed,
+    before,
+    after,
+    domain: opts.domain ?? null,
+    all: opts.all ?? false,
+  });
+}
+
+function runInfo(jar: CookieJar, opts: { json?: boolean }): void {
+  if (opts.json) emit.config({ format: "json" });
+  const i = jar.info();
+  emit.data(i);
+}
+
+function safe(fn: () => void): void {
+  try {
+    fn();
+  } catch (err: unknown) {
+    const msg = err instanceof Error ? err.message : String(err);
+    emit.error({ code: "cookies_error", message: msg });
+    process.exit(1);
+  }
+}