@akagilnc/pi-workflow-roles 0.1.3771 → 0.1.3783

package/dist/host-descriptions.js

@@ -45,15 +45,56 @@ export const HOST_DESCRIPTIONS = Object.freeze({
         }),
     }),
 });
+/**
+ * Headless CLI family (#645). Claude is the first row; codex (#646) adds another.
+ * fixedArgs: print mode, isolation without `--bare` (OAuth stays), full permissions.
+ * `--setting-sources` empty = load no user/project/local CLAUDE.md/hooks/skills
+ * (role envelope is delivered via `--system-prompt` wholesale replace).
+ * `--strict-mcp-config` with no `--mcp-config` drops operator MCP + claude.ai connectors.
+ */
+export const HEADLESS_HOST_DESCRIPTIONS = Object.freeze({
+    "claude": Object.freeze({
+        binaryFromHome: Object.freeze([".local", "bin", "claude"]),
+        sessionBindingFile: "claude-headless-session.json",
+        fixedArgs: Object.freeze([
+            // One result envelope (not stream-json): typed receipt only; no event-stream copy.
+            "--output-format", "json",
+            "--permission-mode", "bypassPermissions",
+            // Empty sources: no user/project/local operator surface (envelope owns materials).
+            "--setting-sources", "",
+            // With adapter-supplied --mcp-config only (AK relay); drops operator + claude.ai MCP.
+            "--strict-mcp-config",
+        ]),
+        promptFlag: "-p",
+        modelFlag: "--model",
+        effortFlag: "--effort",
+        // File path keeps large role envelopes off ARG_MAX.
+        systemPromptFlag: "--system-prompt-file",
+        jsonSchemaFlag: "--json-schema",
+        mcpConfigFlag: "--mcp-config",
+        sessionIdFlag: "--session-id",
+        resumeFlag: "--resume",
+    }),
+});
 export function lookupHostDescription(host) {
     return Object.hasOwn(HOST_DESCRIPTIONS, host) ? HOST_DESCRIPTIONS[host] : undefined;
 }
+export function lookupHeadlessHostDescription(host) {
+    return Object.hasOwn(HEADLESS_HOST_DESCRIPTIONS, host) ? HEADLESS_HOST_DESCRIPTIONS[host] : undefined;
+}
+export function lookupHostFamily(host) {
+    if (lookupHostDescription(host) !== undefined)
+        return "acp";
+    if (lookupHeadlessHostDescription(host) !== undefined)
+        return "headless";
+    return undefined;
+}
 export function packagedExternalHostNames() {
-    return Object.keys(HOST_DESCRIPTIONS);
+    return [...Object.keys(HOST_DESCRIPTIONS), ...Object.keys(HEADLESS_HOST_DESCRIPTIONS)];
 }
-/** Legal persistent/invocation host: default pi, or a table key. */
+/** Legal persistent/invocation host: default pi, or a table key (any family). */
 export function assertRegisteredHostName(host) {
-    if (host === DEFAULT_ROLE_TURN_HOST || lookupHostDescription(host) !== undefined) {
+    if (host === DEFAULT_ROLE_TURN_HOST || lookupHostFamily(host) !== undefined) {
         return host;
     }
     throw new Error(`unregistered host: ${host}`);

package/dist/public-cli/load-production-external-host.js

@@ -0,0 +1,19 @@
+/**
+ * Family-dispatch loader for packaged external RoleTurnHost factories (#645).
+ * ACP rows → production ACP host; headless rows → production headless host.
+ * Unregistered names fail closed before any import.
+ */
+import { lookupHostFamily } from "../host-descriptions.js";
+import { loadProductionAcpHostFactory } from "./load-production-acp-host.js";
+import { loadProductionHeadlessHostFactory } from "./load-production-headless-host.js";
+/** Resolve the production host factory for one registered external host key. */
+export async function loadProductionExternalHostFactory(packageRoot, host) {
+    const family = lookupHostFamily(host);
+    if (family === "acp") {
+        return loadProductionAcpHostFactory(packageRoot, host);
+    }
+    if (family === "headless") {
+        return loadProductionHeadlessHostFactory(packageRoot, host);
+    }
+    throw new Error(`unregistered host: ${host}`);
+}

package/dist/public-cli/load-production-headless-host.js

@@ -0,0 +1,36 @@
+var __rewriteRelativeImportExtension = (this && this.__rewriteRelativeImportExtension) || function (path, preserveJsx) {
+    if (typeof path === "string" && /^\.\.?\//.test(path)) {
+        return path.replace(/\.(tsx)$|((?:\.d)?)((?:\.[^./]+?)?)\.([cm]?)ts$/i, function (m, tsx, d, ext, cm) {
+            return tsx ? preserveJsx ? ".jsx" : ".js" : d && (!ext || !cm) ? m : (d + ext + "." + cm.toLowerCase() + "js");
+        });
+    }
+    return path;
+};
+/**
+ * Deferred loader for the packaged generic headless RoleTurnHost factory (#645).
+ *
+ * Public ak-role bin must not statically value-import the production host (or its
+ * role-runtime edges). Specifier is runtime-constructed so esbuild leaves this
+ * import external (ADR 0052 discovery stays peer-free).
+ */
+import { existsSync } from "node:fs";
+import { join } from "node:path";
+import { pathToFileURL } from "node:url";
+import { lookupHeadlessHostDescription } from "../host-descriptions.js";
+/**
+ * Resolve the production headless host factory for one registered headless host
+ * key without a static graph edge into the public CLI bundle.
+ */
+export async function loadProductionHeadlessHostFactory(packageRoot, host) {
+    const description = lookupHeadlessHostDescription(host);
+    if (description === undefined) {
+        throw new Error(`unregistered headless host: ${host}`);
+    }
+    const built = join(packageRoot, "dist/headless-host/production-host.js");
+    const source = join(packageRoot, "src/headless-host/production-host.ts");
+    const target = existsSync(built) ? built : source;
+    const href = pathToFileURL(target).href;
+    const mod = (await import(__rewriteRelativeImportExtension(href)));
+    const create = mod.createProductionHeadlessRoleTurnHost;
+    return (options) => create({ ...options, description });
+}