@indigoai-us/hq-cli 5.60.0 → 5.62.0

package/dist/commands/secrets.js

@@ -1,5 +1,5 @@
 
-!function(){try{var e="undefined"!=typeof window?window:"undefined"!=typeof global?global:"undefined"!=typeof globalThis?globalThis:"undefined"!=typeof self?self:{},n=(new e.Error).stack;n&&(e._sentryDebugIds=e._sentryDebugIds||{},e._sentryDebugIds[n]="3b78d543-70d6-52e2-b19f-fa2650534e97")}catch(e){}}();
+!function(){try{var e="undefined"!=typeof window?window:"undefined"!=typeof global?global:"undefined"!=typeof globalThis?globalThis:"undefined"!=typeof self?self:{},n=(new e.Error).stack;n&&(e._sentryDebugIds=e._sentryDebugIds||{},e._sentryDebugIds[n]="136bd272-0091-5fce-9a93-a2a375f98b38")}catch(e){}}();
 import chalk from "chalk";
 import * as readline from "node:readline";
 import { spawn } from "node:child_process";
@@ -153,6 +153,81 @@ function describeSecretAclPrincipal(principal) {
         ? "@all (entire company)"
         : principal.granteeId;
 }
+// Mirrors hq-pro's server-authoritative KNOWN_DESTINATION_REGISTRY
+// (src/vault-service/handlers/destination-registry.ts) — a KNOWN host's
+// --auth-style is optional because the server resolves the recipe itself.
+// This client-side copy exists purely so an UNKNOWN host with no
+// --auth-style can be rejected immediately with a clear, actionable message
+// instead of a round trip; the server remains the authoritative validator
+// (this list drifting stale merely means one extra CLI round trip, not a
+// security gap — the server still 400s an unrecognized host with no recipe).
+const KNOWN_DESTINATION_HOSTS = new Set([
+    "api.anthropic.com",
+    "api.openai.com",
+    "api.stripe.com",
+]);
+// Parses `--auth-style` into the InjectionRecipe shape the server expects.
+// Returns `null` (with a printed error) for an unrecognized value.
+function parseAuthStyle(authStyle) {
+    if (authStyle === "bearer") {
+        return { header: "authorization", scheme: "bearer" };
+    }
+    if (authStyle === "x-api-key") {
+        return { header: "x-api-key", scheme: "raw" };
+    }
+    const headerMatch = authStyle.match(/^header:(.+)$/);
+    if (headerMatch) {
+        const headerName = headerMatch[1].trim();
+        if (!headerName) {
+            console.error(chalk.red(`Invalid --auth-style 'header:': must name a header, e.g. header:X-Custom-Key`));
+            return null;
+        }
+        return { header: headerName, scheme: "raw" };
+    }
+    console.error(chalk.red(`Invalid --auth-style '${authStyle}': must be one of bearer, x-api-key, or header:NAME`));
+    return null;
+}
+// Validates `--destination` is a bare HTTPS scheme+host URL (no path, query,
+// port). Mirrors hq-pro's `validateDestinations` server-side check
+// (src/vault-service/handlers/secrets.ts) so a malformed URL is caught
+// locally with an actionable message rather than a round trip — the server
+// re-validates and remains authoritative.
+export function parseDestinationUrl(raw) {
+    let parsed;
+    try {
+        parsed = new URL(raw);
+    }
+    catch {
+        console.error(chalk.red(`Invalid --destination '${raw}': must be a valid URL`));
+        return { ok: false };
+    }
+    if (parsed.protocol !== "https:") {
+        console.error(chalk.red(`Invalid --destination '${raw}': must use https://`));
+        return { ok: false };
+    }
+    if (!parsed.hostname) {
+        console.error(chalk.red(`Invalid --destination '${raw}': missing hostname`));
+        return { ok: false };
+    }
+    // Reject an embedded `user:pass@host` credential segment explicitly rather
+    // than letting `new URL()` silently drop it (mirrors hq-pro's authoritative
+    // `validateDestinations`; the server re-validates and remains authoritative).
+    if (parsed.username !== "" || parsed.password !== "") {
+        console.error(chalk.red(`Invalid --destination '${raw}': must not contain embedded userinfo (user:pass@) credentials`));
+        return { ok: false };
+    }
+    if ((parsed.pathname !== "" && parsed.pathname !== "/") ||
+        parsed.search !== "" ||
+        parsed.hash !== "") {
+        console.error(chalk.red(`Invalid --destination '${raw}': must be a bare scheme+host URL with no path, query, or fragment (e.g. https://api.openai.com)`));
+        return { ok: false };
+    }
+    if (parsed.port !== "") {
+        console.error(chalk.red(`Invalid --destination '${raw}': must not specify a port`));
+        return { ok: false };
+    }
+    return { ok: true, url: `https://${parsed.hostname}`, hostname: parsed.hostname };
+}
 function normalizeSecretTier(tier) {
     return tier === "sensitive" || tier === "nuclear" ? tier : "standard";
 }
@@ -184,8 +259,16 @@ async function buildSecretUsage(channel, scriptPath, scriptId, attestationLevel
         },
     };
 }
+// Commander collector for `--only`: accumulates across REPEATED flags instead
+// of the last one silently winning, and each value may still be
+// comma-separated. So `--only A,B`, `--only A --only B`, and
+// `--only A,B --only C` all resolve to the full list.
+export function collectSecretNames(value, previous) {
+    const parsed = value.split(",").map((k) => k.trim()).filter(Boolean);
+    return (previous ?? []).concat(parsed);
+}
 function parseSecretNameList(input) {
-    const keys = input.split(",").map((k) => k.trim()).filter(Boolean);
+    const keys = input ?? [];
     if (keys.length === 0) {
         console.error(chalk.red("Error: --only requires at least one secret name."));
         process.exit(1);
@@ -378,12 +461,56 @@ export function registerSecretsCommand(program) {
         .command("set <name>")
         .description("Create or update a secret")
         .option("--from-stdin", "Read secret value from piped stdin")
+        .option("--high-security", "Mark the secret high-security: it can never be revealed or injected locally, only used through the HQ secret proxy (requires --destination)")
+        .option("--destination <https-url>", "Approved scheme+host HTTPS URL the proxy may forward this secret to (e.g. https://api.openai.com); required with --high-security")
+        .option("--auth-style <style>", "How the proxy attaches the key upstream: bearer | x-api-key | header:NAME. Optional for known destinations (auto-resolved server-side); required for unknown ones")
         .action(async (name, opts) => {
         try {
             if (!SECRET_NAME_PATTERN.test(name)) {
                 console.error(chalk.red(`Invalid secret name '${name}': must match ^[A-Z][A-Z0-9_]*(/[A-Z][A-Z0-9_]+)*$ (e.g. MY_API_KEY or DEV/MY_KEY)`));
                 process.exit(1);
             }
+            // secrets-proxy-per-secret-destination US-006: --high-security marks
+            // the secret so it can only ever be used through the server-side
+            // proxy (never revealed/injected locally — that refusal is the
+            // pre-existing consumption-side behavior in `get`/`exec`/`env` above,
+            // unchanged by this story). It REQUIRES a --destination: the proxy
+            // (hq-pro US-002) fails closed with no destination configured, so
+            // catching the missing pin here is a clear, immediate CLI error
+            // rather than a deferred proxy-time failure.
+            let destinations;
+            let injection;
+            if (opts.highSecurity) {
+                if (!opts.destination) {
+                    console.error(chalk.red("Error: --high-security requires --destination <https-url> (e.g. --destination https://api.openai.com)."));
+                    process.exit(1);
+                }
+                const destResult = parseDestinationUrl(opts.destination);
+                if (!destResult.ok) {
+                    process.exit(1);
+                }
+                destinations = [destResult.url];
+                if (opts.authStyle) {
+                    const recipe = parseAuthStyle(opts.authStyle);
+                    if (!recipe) {
+                        process.exit(1);
+                    }
+                    injection = recipe;
+                }
+                else if (!KNOWN_DESTINATION_HOSTS.has(destResult.hostname)) {
+                    // Unknown host + no explicit recipe: the server would reject this
+                    // 400 anyway (US-004 registry lookup only, never guesses) — fail
+                    // fast locally with an actionable message instead of a round trip.
+                    console.error(chalk.red(`Error: unknown destination host '${destResult.hostname}' — provide --auth-style <bearer|x-api-key|header:NAME> (known hosts auto-resolve: ${[...KNOWN_DESTINATION_HOSTS].join(", ")}).`));
+                    process.exit(1);
+                }
+                // Known host + no --auth-style: leave `injection` undefined so the
+                // server (US-004) auto-resolves the recipe from its registry.
+            }
+            else if (opts.destination || opts.authStyle) {
+                console.error(chalk.red("Error: --destination/--auth-style require --high-security."));
+                process.exit(1);
+            }
             let value;
             if (opts.fromStdin) {
                 if (process.stdin.isTTY) {
@@ -419,15 +546,27 @@ export function registerSecretsCommand(program) {
                 token,
                 path: `/secrets/${encodeURIComponent(companyUid)}`,
                 method: "POST",
-                body: { name, value },
+                body: {
+                    name,
+                    value,
+                    // Only present when --high-security was passed — an ordinary
+                    // `set` with no flags sends exactly `{ name, value }`, byte-for-
+                    // byte unchanged from before this story.
+                    ...(opts.highSecurity ? { highSecurity: true } : {}),
+                    ...(destinations ? { destinations } : {}),
+                    ...(injection ? { injection } : {}),
+                },
             });
             if (!res.ok) {
-                const body = await res.json().catch(() => ({}));
-                console.error(chalk.red(`Failed to set secret: ${body.error ?? res.statusText}`));
+                const body = (await res.json().catch(() => ({})));
+                console.error(chalk.red(`Failed to set secret: ${extractApiMessage(body, res.statusText)}`));
                 process.exit(1);
             }
             removeCacheEntry(companyUid, name);
             console.log(chalk.green(formatSecretSaved(name, scopeLabel)));
+            if (opts.highSecurity) {
+                console.log(chalk.dim(`  High-security: destination pinned to ${destinations?.[0]}. This value can never be revealed or injected locally — only used through the HQ secret proxy.`));
+            }
         }
         catch (err) {
             console.error(chalk.red("Error:"), err instanceof Error ? err.message : String(err));
@@ -873,11 +1012,11 @@ export function registerSecretsCommand(program) {
         .description("Run a command in the hosted sandbox with named secrets injected as env vars; open egress, secrets never touch this machine")
         .option("--company <slug>", "Company slug (resolves to companyUid)")
         .option("--personal", "Operate on the caller's personal vault (no sharing)")
-        .option("--only <keys>", "Comma-separated list of secret names to inject (required)")
+        .option("--only <keys>", "Secret names to inject (comma-separated; may be repeated) (required)", collectSecretNames)
         .allowUnknownOption(true)
         .action(async (opts, cmd) => {
         try {
-            if (!opts.only || opts.only.trim().length === 0) {
+            if (!opts.only || opts.only.length === 0) {
                 console.error(chalk.red("Error: --only is required and must name at least one secret."));
                 process.exit(1);
             }
@@ -920,7 +1059,7 @@ export function registerSecretsCommand(program) {
     secrets
         .command("exec")
         .description("Run a command with secrets injected as env vars")
-        .requiredOption("--only <keys>", "Comma-separated list of secret names to inject (required)")
+        .requiredOption("--only <keys>", "Secret names to inject (comma-separated; may be repeated) (required)", collectSecretNames)
         .option("--script <path>", "Attach local script identity for script-locked secrets")
         .allowUnknownOption(true)
         .action(async (_opts, cmd) => {
@@ -976,7 +1115,7 @@ export function registerSecretsCommand(program) {
     secrets
         .command("env")
         .description("Print 'export KEY=VALUE' lines suitable for: source <(hq secrets env --only K1,K2)")
-        .requiredOption("--only <keys>", "Comma-separated list of secret names to print (required)")
+        .requiredOption("--only <keys>", "Secret names to print (comma-separated; may be repeated) (required)", collectSecretNames)
         .option("--script <path>", "Attach local script identity for script-locked secrets")
         .action(async (opts) => {
         try {
@@ -1258,4 +1397,4 @@ export function registerSecretsCommand(program) {
     });
 }
 //# sourceMappingURL=secrets.js.map
-//# debugId=3b78d543-70d6-52e2-b19f-fa2650534e97
+//# debugId=136bd272-0091-5fce-9a93-a2a375f98b38

package/dist/commands/skill.d.ts

@@ -0,0 +1,153 @@
+/**
+ * `hq skill` subcommand group (US-017).
+ *
+ * Terminal / scriptable access to the skill collaboration loop:
+ *
+ *   hq skill suggest <uid|path>   Propose a change to a skill from working edits.
+ *   hq skill list-suggestions     Show the review inbox (suggestions on skills you own).
+ *   hq skill review <sgn_…>       Accept (merge) or decline a pending suggestion.
+ *
+ * This is a THIN front-end over the SAME wired hq-pro routes the MCP surface
+ * (US-007) and the console merge path (US-009) use — there is NO forked
+ * suggestion or merge logic here. The CLI reads the local working SKILL.md,
+ * computes the proposed content (+ its base for a diff), and POSTs to:
+ *
+ *   CREATE  POST /v1/files/skills/company/{slug}/{skillUid}/suggestions
+ *   LIST    POST /v1/files/skills/company/{slug}/suggestions/list
+ *   ACCEPT  POST /v1/files/skills/company/{slug}/{skillUid}/suggestions/{id}/accept
+ *   DECLINE POST /v1/files/skills/company/{slug}/{skillUid}/suggestions/{id}/decline
+ *
+ * The skill routes are keyed on the company SLUG (path param, resolved
+ * server-side via findEntityBySlug) — NOT the companyUid the vault/ACL routes
+ * use — so this module resolves a slug (from `--company` or the active company)
+ * and passes it straight through.
+ *
+ * Lock semantics (AC3): a suggest against a skill the caller cannot WRITE still
+ * SUCCEEDS as a proposal. The CREATE route is MEMBER-gated (never write-gated),
+ * so this command performs NO client-side lock/permission pre-check — it always
+ * posts and renders whatever the server returns. A locked-out member lands a
+ * suggestion, never a hard permission error.
+ *
+ * Attribution (AC4): the invoking identity (from the Cognito JWT) is the server-
+ * derived `authorPersonUid`; the CLI never sends an author. An optional
+ * `--note` rides as `authorNote` (the change's rationale / failure context).
+ */
+import { Command } from "commander";
+/**
+ * A `skl_…` argument to `suggest` is a skill UID (resolve the local file from
+ * it); anything else is a filesystem path. Lenient on the suffix (the strict
+ * `skl_<ulid>` shape is `isSkillUid` on the server) so a hand-typed / fixture
+ * uid still routes to the uid branch.
+ */
+export declare const SKILL_UID_PATTERN: RegExp;
+/** A `sgn_…` suggestion id — the `review` target and the LIST row key. */
+export declare const SUGGESTION_ID_PATTERN: RegExp;
+/**
+ * Read the top-level `skill_uid` from a SKILL.md's YAML frontmatter. Mirrors
+ * hq-pro's `parseSkillFrontmatter` (block extraction → YAML parse → read the
+ * top-level `skill_uid` string). Returns `undefined` when there is no
+ * frontmatter, it fails to parse, or `skill_uid` is absent / not a `skl_…`
+ * string. Never throws.
+ */
+export declare function parseSkillUid(md: string): string | undefined;
+/** sha256 hex of a string — the base-version fingerprint the server records (AC2). */
+export declare function sha256Hex(content: string): string;
+export interface SuggestionCreateBody {
+    proposedContent: string;
+    baseContent?: string;
+    baseContentHash?: string;
+    authorNote?: string;
+}
+/**
+ * Build the CREATE request body from the resolved proposed content and an
+ * optional base. Mirrors the server's two payload shapes:
+ *   - `baseContent` present → the server derives the unified diff + base hash
+ *     (the diff-by-default path). A no-op (base === proposed) is rejected here
+ *     rather than round-tripped to an EmptySuggestion 400.
+ *   - no base → a `full-file` proposal; the server REQUIRES a `baseContentHash`,
+ *     so we fingerprint the proposed content (a "here is my whole file" proposal
+ *     with no base to diff against).
+ * An empty / whitespace-only note is dropped (kept absent, not blank).
+ */
+export declare function buildSuggestionCreateBody(input: {
+    proposedContent: string;
+    baseContent?: string;
+    note?: string;
+}): SuggestionCreateBody;
+/**
+ * Map an hq-pro skill route error to a single user-facing line. Pure so the
+ * status → copy mapping is unit-tested independently of the network. Prefers the
+ * server's own `error` / `message` (they carry the actionable specifics — e.g.
+ * "Skill not found", "You need write access to this skill…").
+ */
+export declare function mapSkillError(status: number, body: Record<string, unknown>): string;
+/** LIST inbox row shape returned by `suggestionToWire` on the server. */
+export interface SuggestionRow {
+    suggestionId: string;
+    skillUid: string;
+    authorPersonUid: string;
+    status: string;
+    baseChanged: boolean;
+    presentation?: string;
+    unifiedDiff?: string;
+    fullContent?: string;
+    baseContentHash?: string;
+    currentContentHash?: string;
+    authorNote?: string;
+    createdAt: string;
+    path: string;
+}
+/**
+ * Render the review inbox as a table (one row per suggestion), optionally
+ * printing each suggestion's unified diff (or full proposed file, when the base
+ * drifted / the proposal is full-file) beneath its row. Pure → snapshot-testable.
+ */
+export declare function formatSuggestionsList(suggestions: SuggestionRow[], opts?: {
+    showDiff?: boolean;
+}): string;
+/** Read `.hq/config.json`'s `activeCompany` (mirrors signals/sources). */
+export declare function readActiveCompanySlug(hqRoot: string): string | undefined;
+/**
+ * The skill routes are keyed on the company SLUG. Precedence: explicit
+ * `--company` → `.hq/config.json` activeCompany. Throws with actionable copy
+ * when neither is available.
+ */
+export declare function resolveCompanySlug(flag: string | undefined, hqRoot?: string): string;
+export interface ResolvedSkillTarget {
+    /** Absolute path to the SKILL.md. */
+    filePath: string;
+    /** The `skl_…` uid read from its frontmatter (or the uid arg). */
+    skillUid: string;
+    /** The working-tree SKILL.md content — the proposed content. */
+    content: string;
+}
+/**
+ * Recursively find a SKILL.md whose frontmatter `skill_uid` equals `uid`,
+ * searching each root breadth-first with a bounded depth (skips VCS / build /
+ * dependency dirs). Returns the first match's absolute path, or null.
+ */
+export declare function findSkillFileByUid(roots: string[], uid: string, maxDepth?: number): string | null;
+/**
+ * Resolve a `suggest` target (a `skl_…` uid OR a filesystem path) to the local
+ * SKILL.md, its uid, and its content. A uid is resolved by scanning the company
+ * skills dir and the cwd; a path is read directly (a directory → its SKILL.md),
+ * with the uid read from the file's frontmatter.
+ */
+export declare function resolveSkillTarget(target: string, deps: {
+    cwd: string;
+    hqRoot: string;
+    companySlug: string;
+}): ResolvedSkillTarget;
+/**
+ * Read the committed (HEAD) version of a file from its git repo — the diff base
+ * for "propose my working changes". Returns null when the file is untracked, not
+ * in a repo, or git is unavailable (the caller then falls back to full-file, or
+ * errors under `--diff`). Never throws.
+ */
+export declare function readGitBase(filePath: string): Promise<string | null>;
+/** Injectable git-base seam so `suggest` is testable without a real repo. */
+export type GitBaseReader = (filePath: string) => Promise<string | null>;
+export declare function registerSkillCommand(program: Command, deps?: {
+    gitBase?: GitBaseReader;
+}): Command;
+//# sourceMappingURL=skill.d.ts.map