antechamber 0.0.0-stage → 0.1.1

package/dist/agent-name.js

@@ -0,0 +1,110 @@
+/**
+ * Agent-name detection: the adapter reports one OpenCode "agent" to the UI.
+ * Resolution order (<agent dir> is piAgentDir(), ~/.omo/agent by default):
+ *   1. ANTECHAMBER_AGENT env override
+ *   2. <agent dir>/../oh-my-pi.jsonc → orchestrator.agentName
+ *   3. <agent dir>/../omo.jsonc exists (an OmO install) → "OmO"
+ *   4. <agent dir>/settings.json packages containing oh-my-pi → "oh-my-pi"
+ *   5. "build" (plain pi)
+ * The result is memoized: config changes require an adapter restart.
+ */
+import { existsSync, readFileSync } from "node:fs";
+import { homedir } from "node:os";
+import { dirname, join } from "node:path";
+import { envSetting } from "./config.js";
+import { piAgentDir } from "./agent-dir.js";
+/** Strip JSONC comments without touching string literals or joining tokens. */
+function stripComments(text) {
+    let out = "";
+    let inString = false;
+    let escaped = false;
+    for (let i = 0; i < text.length; i++) {
+        const c = text[i];
+        if (inString) {
+            out += c;
+            if (escaped)
+                escaped = false;
+            else if (c === "\\")
+                escaped = true;
+            else if (c === '"')
+                inString = false;
+            continue;
+        }
+        if (c === '"') {
+            inString = true;
+            out += c;
+            continue;
+        }
+        if (c === "/" && text[i + 1] === "/") {
+            while (i < text.length && text[i] !== "\n")
+                i++;
+            out += "\n";
+            continue;
+        }
+        if (c === "/" && text[i + 1] === "*") {
+            out += " ";
+            i += 2;
+            while (i < text.length && !(text[i] === "*" && text[i + 1] === "/")) {
+                if (text[i] === "\n")
+                    out += "\n";
+                i++;
+            }
+            if (i === text.length)
+                throw new SyntaxError("Unterminated JSONC block comment");
+            i++;
+            continue;
+        }
+        out += c;
+    }
+    return out;
+}
+export function detectAgentName(env = process.env, home = homedir(), fs = {
+    existsSync,
+    readFileSync,
+}) {
+    const fromEnv = envSetting("AGENT", env);
+    if (typeof fromEnv === "string" && fromEnv.trim() !== "")
+        return fromEnv.trim();
+    const agentDir = piAgentDir(env, home);
+    try {
+        const raw = fs.readFileSync(join(dirname(agentDir), "oh-my-pi.jsonc"), "utf8");
+        const cfg = JSON.parse(stripComments(raw));
+        const name = cfg.orchestrator?.agentName;
+        if (typeof name === "string" && name.trim() !== "")
+            return name.trim();
+    }
+    catch {
+        // missing or unparseable config → fall through
+    }
+    if (fs.existsSync(join(dirname(agentDir), "omo.jsonc")))
+        return "OmO";
+    try {
+        const raw = fs.readFileSync(join(agentDir, "settings.json"), "utf8");
+        const settings = JSON.parse(raw);
+        if (Array.isArray(settings.packages) &&
+            settings.packages.some((p) => typeof p === "string" && p.includes("oh-my-pi"))) {
+            return "oh-my-pi";
+        }
+    }
+    catch {
+        // missing or unparseable settings → fall through
+    }
+    return "build";
+}
+let cached;
+export function getAgentName() {
+    if (cached === undefined)
+        cached = detectAgentName();
+    return cached;
+}
+/**
+ * Agent names the adapter publishes to OpenChamber's picker. pi has exactly one
+ * agent. The resolved pi name is published first so OpenChamber chooses it for
+ * new sessions; `build` remains a compatibility alias for existing sessions.
+ * Both names run the same pi agent — the requested agent name is not forwarded
+ * to pi. When pi's name already is `build` the list collapses to one.
+ */
+export function getExposedAgentNames() {
+    const piName = getAgentName();
+    return piName === "build" ? ["build"] : [piName, "build"];
+}

package/dist/approvals.d.ts

@@ -0,0 +1,86 @@
+import type { PermissionRequest, PermissionV2Request, QuestionInfo, QuestionRequest, EventPermissionAsked, EventPermissionReplied, EventQuestionReplied, EventQuestionRejected } from "@opencode-ai/sdk/v2";
+type WithoutEventID<T> = T extends {
+    id: string;
+} ? Omit<T, "id"> : never;
+export type ApprovalEvent = WithoutEventID<EventPermissionAsked | EventPermissionReplied | EventQuestionRejected> | {
+    type: "question.asked";
+    properties: PendingQuestion;
+} | {
+    type: "question.replied";
+    properties: EventQuestionReplied["properties"] & {
+        comment?: string;
+        formAnswer?: Record<string, string | string[]>;
+    };
+};
+export type PermissionReply = "once" | "always" | "reject";
+export type PendingPermission = PermissionRequest;
+export type PendingQuestion = QuestionRequest & {
+    questionIDs?: string[];
+    metadata?: Record<string, unknown>;
+};
+export type ExtensionUiResponse = Record<string, unknown>;
+export declare class ApprovalInputError extends Error {
+}
+interface Context {
+    sessionID: string;
+    directory: string;
+    messageID: string;
+    send: (response: Record<string, unknown>) => void;
+}
+interface UIRequest {
+    id: string;
+    method: "select" | "confirm" | "input" | "editor" | "question";
+    title: string;
+    options: string[];
+    toolCallId?: string;
+    timeout?: number;
+    requestId?: string;
+    questions?: Array<QuestionInfo & {
+        id: string;
+    }>;
+    waitForAnswer?: boolean;
+    deadlineAtMs?: number;
+    draft?: Record<string, unknown>;
+}
+export declare function extensionUiRequestFrom(value: Record<string, unknown>): UIRequest | undefined;
+export declare function parsePermissionTitle(title: string): {
+    permission: string;
+    patterns: string[];
+};
+export declare function toV2Permission(card: PermissionRequest): PermissionV2Request;
+/** Session-scoped dialog lifecycle; RPC select replies are labels, never indices. */
+export declare class ApprovalBridge {
+    private sessionID;
+    private send;
+    private messageID;
+    private acknowledge?;
+    private pending;
+    private questionCalls;
+    private followups;
+    private emit;
+    private settled;
+    constructor(sessionID: string, emit: (event: ApprovalEvent) => void, send: (response: ExtensionUiResponse) => void, messageID: () => string | undefined, acknowledge?: ((response: ExtensionUiResponse) => Promise<boolean>) | undefined);
+    private context;
+    handle(request: UIRequest): void;
+    noteToolStart(toolCallId: string, toolName: string, args: unknown): void;
+    noteToolEnd(toolCallId: string): void;
+    finishTurn(): void;
+    cancelAll(): void;
+    permissions(sessionID?: string, directory?: string): PermissionRequest[];
+    questionRequests(sessionID?: string, directory?: string): PendingQuestion[];
+    questions(): PendingQuestion[];
+    hasPending(sessionID: string): boolean;
+    /** Merge a snapshot only after live subscriptions have been installed. */
+    hydrate(questions: unknown): void;
+    observeQuestion(ev: Record<string, unknown>): void;
+    observe(context: Context, ev: Record<string, unknown>): void;
+    private ask;
+    replyPermission(id: string, reply: PermissionReply, message?: string, sessionID?: string): boolean;
+    replyQuestion(id: string, answers: string[][], sessionID?: string, comment?: string): boolean | Promise<boolean>;
+    rejectQuestion(id: string, sessionID?: string): boolean | Promise<boolean>;
+    private respondStructured;
+    private follow;
+    private remove;
+    clear(sessionID: string, cancel: boolean, callID?: string): void;
+}
+export {};