@aui.io/apollo 0.1.7 → 0.1.10

package/node_modules/@aui.io/apollo-tui/dist/src/lib/actions.js

@@ -0,0 +1,1019 @@
+/**
+ * TUI action dispatcher — calls apollo-core services and returns UI effects.
+ */
+import { mkdir, writeFile } from "node:fs/promises";
+import { homedir } from "node:os";
+import path from "node:path";
+import { readBinding, readCredentials, resolveContext, writeCredentials, } from "@aui.io/apollo-core/config/index.js";
+import { ConfigError } from "@aui.io/apollo-core/errors/index.js";
+import { importBundle, listVersions, localDiff, pullBundle, pushBundle, remoteDiff, validateLocalBundle, } from "@aui.io/apollo-core/services/bundles.js";
+import { loginWithBrowser, loginWithOtp, loginWithToken, logout as logoutSession, requestOtp, } from "@aui.io/apollo-core/services/auth.js";
+import { createClients } from "@aui.io/apollo-core/services/clients.js";
+import { setEnvironment } from "@aui.io/apollo-core/services/env.service.js";
+import { bindAgent, createAgent, createProject, listAgents, listOrganizations, listProjects, unlinkAgent, useAgent, useOrganization, useProject, } from "@aui.io/apollo-core/services/hierarchy.js";
+import { createThread, debugInteraction, listAgentThreads, listMessages, listThreads, resolveSendVersion, trace as fetchTrace, } from "@aui.io/apollo-core/services/messaging.js";
+import { createCollection, createEndpoint, deleteEndpoint, deleteMockDb, describeMockDb, executeEndpoint, exportMockDb, getEndpoint, inspectSession, listCollections, listEndpoints, normalizeSchema, parseJsonFlag, provisionMockDb, resetSession, rotateMgmtKey, rotateRuntimeKey, seedRows, statusMockDb, storedKeys, updateCollection, updateEndpoint, wireMockDbConnection, } from "@aui.io/apollo-core/services/mockdb.js";
+import { listProfiles, useProfile } from "@aui.io/apollo-core/services/profile.service.js";
+import { getStatus } from "@aui.io/apollo-core/services/status.service.js";
+import { upgradeCli } from "@aui.io/apollo-core/services/upgrade.js";
+import { listWorkspaces } from "@aui.io/apollo-core/services/workspace.service.js";
+import { installSkills } from "@aui.io/apollo-core/skills/install.js";
+import { allocateAgentDirectory, clearActiveAgent, readWorkspace, registerAgent, resolveAgentPath, selectAgent, } from "@aui.io/apollo-core/workspace/store.js";
+import { messagesToTurns } from "../talk/data.js";
+import { pickerDisplayName } from "./picker.js";
+import { detectIdes, ideTargetDir, launchIde } from "./ide.js";
+import { enterWorkspace, followAccountWorkspace, PLACE_CREATE_ID, PLACE_SKIP_ID, } from "./place.js";
+import { homeishPath } from "./scope.js";
+function item(id, name, detail) {
+    const label = pickerDisplayName(name, id);
+    if (detail !== undefined) {
+        return detail && detail !== label
+            ? { id, label, detail }
+            : { id, label };
+    }
+    return label !== id ? { id, label, detail: id } : { id, label };
+}
+const PLAYGROUND_URLS = {
+    staging: "https://staging-playground-v3.aui.io",
+    production: "https://apollo-playground.aui.io",
+    eu: "https://playground-eu-v3.aui.io",
+};
+function diffSummary(diff) {
+    const total = diff.added.length + diff.changed.length + diff.removed.length;
+    if (total === 0)
+        return "no changes";
+    return `+${diff.added.length} ~${diff.changed.length} -${diff.removed.length}`;
+}
+async function persistToken(context, token, refreshToken) {
+    const credentials = await readCredentials(homedir());
+    const current = credentials[context.profile]?.[context.environment];
+    credentials[context.profile] ??= {};
+    credentials[context.profile][context.environment] = {
+        access_token: token,
+        ...(refreshToken
+            ? { refresh_token: refreshToken }
+            : current?.refresh_token
+                ? { refresh_token: current.refresh_token }
+                : {}),
+        ...(current?.user_id ? { user_id: current.user_id } : {}),
+    };
+    await writeCredentials(homedir(), credentials);
+}
+function orgIdOf(org) {
+    const id = org.id ?? org._id;
+    if (!id)
+        throw new Error("Organization is missing an id.");
+    return id;
+}
+export async function loadPickerCatalog(kind, context) {
+    const clients = createClients(context);
+    switch (kind) {
+        case "env":
+            return [
+                item("staging", "staging"),
+                item("production", "production"),
+                item("eu", "eu"),
+            ];
+        case "login-method":
+            return [
+                item("browser", "browser SSO"),
+                item("email", "email OTP"),
+                item("token", "paste JWT"),
+            ];
+        case "profile":
+            return (await listProfiles(context)).map((p) => item(p.name, p.name, p.active ? "active" : p.environments.join(",") || undefined));
+        case "workspace":
+            return (await listWorkspaces(context)).map((w) => item(w.path, w.name ?? path.basename(w.path), w.path));
+        case "place-onboard": {
+            const known = (await listWorkspaces(context)).map((w) => item(w.path, w.name ?? path.basename(w.path), w.path));
+            return [
+                ...known,
+                item(PLACE_CREATE_ID, "Create new workspace…", "path sheet"),
+                item(PLACE_SKIP_ID, "Continue without place", "account-only until /workspace"),
+            ];
+        }
+        case "ide": {
+            const found = detectIdes();
+            if (found.length === 0) {
+                throw new Error("No IDE CLI found on PATH (cursor, code, windsurf, zed, subl, webstorm, idea).");
+            }
+            return found.map((ide) => item(ide.id, ide.label, [ide.bin, ...ide.args].join(" ")));
+        }
+        case "org": {
+            const orgs = await listOrganizations(clients.identity);
+            return orgs.map((o) => item(orgIdOf(o), o.name));
+        }
+        case "project": {
+            const page = await listProjects(clients.management);
+            return page.results.map((p) => {
+                const raw = p;
+                return item(raw.id, raw.name || raw.title || raw.display_name);
+            });
+        }
+        case "agent-local": {
+            if (context.workspaceRoot) {
+                const manifest = await readWorkspace(context.workspaceRoot, false);
+                return (manifest?.agents ?? []).map((a) => item(a.agent_id, a.name, a.path));
+            }
+            const page = await listAgents(context, clients.management);
+            return page.results.map((a) => item(a.id, a.name));
+        }
+        case "agent-cloud": {
+            const page = await listAgents(context, clients.management);
+            const registered = new Set(context.workspaceRoot
+                ? ((await readWorkspace(context.workspaceRoot, false))?.agents ?? []).map((a) => a.agent_id)
+                : []);
+            return page.results.map((a) => item(a.id, a.name, registered.has(a.id) ? `${a.id} · in workspace` : a.id));
+        }
+        case "thread": {
+            // The picker needs an agent (NEEDS_AGENT) — list that agent's threads,
+            // not every conversation the user ever had.
+            const threads = context.agentId
+                ? await listAgentThreads(context, clients.runtime)
+                : await listThreads(context, clients.runtime);
+            return threads.map((t) => item(t.id, t.title || t.id.slice(0, 12), t.id));
+        }
+        case "version": {
+            const page = await listVersions(context, clients.management);
+            return [
+                item("latest", "latest (live)"),
+                ...page.results.map((v) => item(v.version_tag, v.version_tag, v.status)),
+            ];
+        }
+        case "target": {
+            // What replies run against — a session choice, so picking here never
+            // rewrites `.apollorc` (that would silently move the author baseline).
+            const rows = [];
+            if (context.agentRoot) {
+                rows.push(item("local", "local bundle", "replies run this checkout"));
+            }
+            if (context.versionTag) {
+                rows.push(item("bound", `bound · ${context.versionTag}`, "follows .apollorc"));
+            }
+            rows.push(item("latest", "latest (live)", "the published version"));
+            const page = await listVersions(context, clients.management);
+            rows.push(...page.results
+                .filter((v) => v.version_tag !== context.versionTag)
+                .map((v) => item(v.version_tag, v.version_tag, v.status)));
+            return rows;
+        }
+        default:
+            return [];
+    }
+}
+export async function refreshContext() {
+    return resolveContext({});
+}
+function relativeWorkspacePath(root, destination) {
+    const relative = path
+        .relative(path.resolve(root), destination)
+        .split(path.sep)
+        .join("/");
+    resolveAgentPath(root, relative);
+    return relative;
+}
+export async function runSimpleCommand(name, context, args) {
+    const clients = createClients(context);
+    switch (name) {
+        case "status": {
+            const status = await getStatus(context, { check: true });
+            return {
+                toast: `status · env=${status.environment} · agent=${status.agentId ?? "—"}`,
+                jumpTab: "scope",
+                paneTitle: "status",
+                paneLines: [
+                    `env: ${status.environment}`,
+                    `profile: ${status.profile}`,
+                    `workspace: ${status.workspaceRoot ?? "—"}`,
+                    `org: ${status.orgId ?? status.tokenOrgId ?? "—"}`,
+                    `project: ${status.projectId ?? "—"}`,
+                    `agent: ${status.agentId ?? "—"}`,
+                    `version: ${status.versionTag ?? "—"}`,
+                    `auth: ${status.authenticated ? "yes" : "no"}`,
+                ],
+            };
+        }
+        case "validate": {
+            const result = await validateLocalBundle(context, clients.runtime);
+            if (result.valid) {
+                return {
+                    jumpTab: "bundle",
+                    toast: result.program?.id
+                        ? `Valid — ${result.program.id}@${result.program.version ?? "?"}`
+                        : "Program is valid",
+                };
+            }
+            const errors = result.findings.filter((f) => f.level !== "warning");
+            return {
+                jumpTab: "bundle",
+                error: errors[0]?.message ?? "validation failed",
+            };
+        }
+        case "diff": {
+            const remote = args.trim().toLowerCase() === "remote";
+            const diff = remote
+                ? await remoteDiff(context, clients.management)
+                : await localDiff(context);
+            return {
+                jumpTab: "bundle",
+                toast: `diff vs ${remote ? "remote" : "baseline"} · ${diffSummary(diff)}`,
+            };
+        }
+        case "versions": {
+            const page = await listVersions(context, clients.management);
+            return {
+                jumpTab: "bundle",
+                paneTitle: "versions",
+                paneLines: page.results.length === 0
+                    ? ["No versions."]
+                    : page.results.map((v) => `${v.version_tag}\t${v.status}\t${v.label ?? ""}`),
+                toast: `${page.results.length} version(s)`,
+            };
+        }
+        case "schema-pull": {
+            const schemas = await clients.agentSettings.pullSchemas();
+            return {
+                jumpTab: "bundle",
+                toast: `Pulled ${Object.keys(schemas).length} schema(s)`,
+            };
+        }
+        case "wire": {
+            const wired = await wireMockDbConnection(context);
+            return { jumpTab: "mockdb", toast: `Wired ${wired.connectionId}` };
+        }
+        case "mdb-status": {
+            const status = await statusMockDb(context);
+            return {
+                jumpTab: "mockdb",
+                paneTitle: "mockdb status",
+                paneLines: [JSON.stringify(status, null, 2)],
+                toast: "mock DB status",
+            };
+        }
+        case "mdb-describe": {
+            const desc = await describeMockDb(context);
+            return {
+                jumpTab: "mockdb",
+                paneTitle: "mockdb describe",
+                paneLines: [JSON.stringify(desc, null, 2)],
+            };
+        }
+        case "mdb-keys": {
+            const keys = await storedKeys(context);
+            return {
+                jumpTab: "mockdb",
+                paneTitle: "mockdb keys",
+                paneLines: [JSON.stringify(keys, null, 2)],
+            };
+        }
+        case "mdb-export": {
+            const exported = await exportMockDb(context);
+            return {
+                jumpTab: "mockdb",
+                paneTitle: "mockdb export",
+                paneLines: [JSON.stringify(exported, null, 2)],
+                toast: "exported",
+            };
+        }
+        case "mdb-collections": {
+            const cols = await listCollections(context);
+            return {
+                jumpTab: "mockdb",
+                paneTitle: "collections",
+                paneLines: Array.isArray(cols)
+                    ? cols.map((c) => JSON.stringify(c))
+                    : [JSON.stringify(cols, null, 2)],
+            };
+        }
+        case "mdb-endpoints": {
+            const eps = await listEndpoints(context);
+            return {
+                jumpTab: "mockdb",
+                paneTitle: "endpoints",
+                paneLines: Array.isArray(eps)
+                    ? eps.map((e) => JSON.stringify(e))
+                    : [JSON.stringify(eps, null, 2)],
+            };
+        }
+        case "mdb-session": {
+            const key = args.trim();
+            if (!key) {
+                return { error: "Session key required (e.g. /mdb-session <key>)" };
+            }
+            const session = await inspectSession(context, key);
+            return {
+                jumpTab: "mockdb",
+                paneTitle: "session",
+                paneLines: [JSON.stringify(session, null, 2)],
+            };
+        }
+        case "mdb-session-reset": {
+            const key = args.trim();
+            if (!key) {
+                return { error: "Session key required (e.g. /mdb-session-reset <key>)" };
+            }
+            await resetSession(context, key);
+            return { jumpTab: "mockdb", toast: "Session reset" };
+        }
+        case "upgrade": {
+            const result = await upgradeCli("latest", {
+                packageName: "@aui.io/apollo",
+                currentVersion: process.env.npm_package_version ?? "0.0.0",
+            });
+            return {
+                toast: result.upgraded
+                    ? `Upgraded to ${result.available}`
+                    : `Already on ${result.current} (latest ${result.available})`,
+            };
+        }
+        case "new": {
+            // Same wiring as `apollo thread create`: the runtime wants an explicit
+            // version id, so resolve the bound tag (or live version) first.
+            const thread = await resolveSendVersion(context, clients.management)
+                .then((versionId) => createThread(context, clients.runtime, versionId))
+                .catch(() => undefined);
+            return {
+                jumpTab: "chat",
+                chat: [],
+                toast: thread
+                    ? `New thread ${thread.id.slice(0, 12)}`
+                    : "New thread — starts on the first message",
+                // Without a server thread the old id must not linger — the next
+                // send would silently continue the previous conversation.
+                ...(thread ? { threadId: thread.id } : { clearThread: true }),
+            };
+        }
+        default:
+            return { error: `Unhandled command /${name}` };
+    }
+}
+export async function applyPick(commandName, selectedId, context) {
+    const clients = createClients(context);
+    switch (commandName) {
+        case "env": {
+            await setEnvironment(selectedId, context.environment, context.profile);
+            // TUI exception: follow the account's default workspace for this env
+            // (bookmarks are per profile × env) so place matches account.
+            const entered = await followAccountWorkspace({
+                profile: context.profile,
+                environment: selectedId,
+            });
+            return {
+                toast: entered
+                    ? `Env ${selectedId} · entered ${homeishPath(entered)}`
+                    : `Env ${selectedId} — no workspace for this env yet, pick one`,
+                refreshScope: true,
+                ...(entered ? {} : { offerPlace: true }),
+                jumpTab: "scope",
+            };
+        }
+        case "profile": {
+            await useProfile(selectedId, homedir());
+            // The new profile keeps its own env + workspace bookmarks.
+            const fresh = await resolveContext({});
+            const entered = await followAccountWorkspace(fresh);
+            return {
+                toast: entered
+                    ? `Profile ${selectedId} · entered ${homeishPath(entered)}`
+                    : `Profile ${selectedId} — no workspace for ${fresh.environment} yet, pick one`,
+                refreshScope: true,
+                ...(entered ? {} : { offerPlace: true }),
+                jumpTab: "scope",
+            };
+        }
+        case "workspace": {
+            const result = await enterWorkspace(context, selectedId);
+            return {
+                toast: `Entered ${result.path}`,
+                refreshScope: true,
+                jumpTab: "scope",
+            };
+        }
+        case "place-onboard": {
+            if (selectedId === PLACE_SKIP_ID) {
+                return {
+                    toast: "Continuing without a workspace — /workspace when ready",
+                    jumpTab: "scope",
+                };
+            }
+            if (selectedId === PLACE_CREATE_ID) {
+                return { openWorkspaceCreate: true };
+            }
+            const result = await enterWorkspace(context, selectedId);
+            return {
+                toast: `Entered ${result.path}`,
+                refreshScope: true,
+                jumpTab: "scope",
+            };
+        }
+        case "ide": {
+            const target = ideTargetDir(context);
+            if (!target) {
+                return {
+                    error: "Nothing to open — import an agent or enter a workspace first.",
+                };
+            }
+            const available = detectIdes();
+            const ide = available.find((c) => c.id === selectedId);
+            if (!ide) {
+                return {
+                    error: `IDE "${selectedId}" not on PATH (detected: ${available.map((c) => c.id).join(", ") || "none"})`,
+                };
+            }
+            launchIde(ide, target);
+            return {
+                toast: `Opened ${path.basename(target)} in ${ide.label} (new window)`,
+            };
+        }
+        case "org": {
+            const switched = await useOrganization(context, clients.identity, selectedId);
+            await persistToken(context, switched.token, switched.refreshToken);
+            if (context.workspaceRoot &&
+                context.orgId &&
+                context.orgId !== selectedId) {
+                await clearActiveAgent(context.workspaceRoot);
+            }
+            return {
+                toast: `Using organization ${selectedId}`,
+                refreshScope: true,
+                jumpTab: "scope",
+            };
+        }
+        case "project": {
+            const result = await useProject(context, clients.management, selectedId, process.cwd());
+            return {
+                toast: `Using project ${result.project.name}`,
+                refreshScope: true,
+                jumpTab: "scope",
+            };
+        }
+        case "agent": {
+            if (context.workspaceRoot &&
+                (context.bindingFromWorkspace || !context.bindingPath)) {
+                const workspaceRoot = context.workspaceRoot;
+                const manifest = await readWorkspace(workspaceRoot);
+                const candidate = manifest?.agents.find((a) => a.agent_id === selectedId);
+                if (!candidate) {
+                    return {
+                        error: `Agent ${selectedId} not in workspace — /agent-import first`,
+                    };
+                }
+                const candidateRoot = resolveAgentPath(workspaceRoot, candidate.path);
+                const local = await readBinding(candidateRoot);
+                if (local.path !== path.join(candidateRoot, ".apollorc") ||
+                    local.binding?.agent_id !== selectedId) {
+                    return {
+                        error: `Registered artifacts for ${selectedId} have no matching .apollorc — re-import`,
+                    };
+                }
+                if (local.binding.org_id &&
+                    local.binding.org_id !== context.tokenOrgId) {
+                    const switched = await clients.identity.switchOrganization(local.binding.org_id);
+                    const token = switched.token ?? context.token;
+                    if (!token) {
+                        return {
+                            error: `Could not authenticate with organization ${local.binding.org_id}`,
+                        };
+                    }
+                    await persistToken(context, token, switched.refreshToken);
+                }
+                const selected = await selectAgent(workspaceRoot, selectedId);
+                return {
+                    toast: `Using agent ${selected.name}`,
+                    refreshScope: true,
+                    jumpTab: "scope",
+                };
+            }
+            const result = await useAgent(context, clients.management, selectedId, process.cwd());
+            return {
+                toast: `Using agent ${result.agent.name}`,
+                refreshScope: true,
+                jumpTab: "scope",
+            };
+        }
+        case "thread": {
+            const messages = await listMessages(clients.runtime, selectedId);
+            const chat = messagesToTurns(messages);
+            return {
+                jumpTab: "chat",
+                chat,
+                threadId: selectedId,
+                toast: `Thread ${selectedId.slice(0, 12)} · ${chat.length} message(s)`,
+            };
+        }
+        case "target": {
+            // Session-scoped: the TUI applies it to sends; nothing written to disk.
+            if (selectedId === "local") {
+                return {
+                    jumpTab: "chat",
+                    talkTarget: { kind: "local" },
+                    toast: "target: local bundle — replies run this checkout",
+                };
+            }
+            if (selectedId === "bound") {
+                return {
+                    jumpTab: "chat",
+                    talkTarget: { kind: "bound" },
+                    toast: `target: ${context.versionTag ?? "bound"} (follows .apollorc)`,
+                };
+            }
+            if (selectedId === "latest") {
+                return {
+                    jumpTab: "chat",
+                    talkTarget: { kind: "live" },
+                    toast: "target: latest (live)",
+                };
+            }
+            return {
+                jumpTab: "chat",
+                talkTarget: { kind: "tag", tag: selectedId },
+                toast: `target: ${selectedId}`,
+            };
+        }
+        case "version-publish": {
+            if (!context.agentId)
+                return { error: "Select an agent first" };
+            const selected = await clients.management.resolveVersion(context.agentId, selectedId);
+            const result = await clients.management.publishVersion(context.agentId, selected.id);
+            return {
+                jumpTab: "bundle",
+                toast: `Published ${result.version_tag}`,
+                refreshScope: true,
+            };
+        }
+        case "version-archive": {
+            if (!context.agentId)
+                return { error: "Select an agent first" };
+            const selected = await clients.management.resolveVersion(context.agentId, selectedId);
+            const result = await clients.management.archiveVersion(context.agentId, selected.id);
+            return {
+                jumpTab: "bundle",
+                toast: `Archived ${result.version_tag}`,
+            };
+        }
+        default:
+            return { error: `Unhandled pick /${commandName}` };
+    }
+}
+export async function runSheetAction(commandName, values, context) {
+    const text = (name) => {
+        const value = values[name];
+        return typeof value === "string" ? value.trim() : "";
+    };
+    const clients = createClients(context);
+    switch (commandName) {
+        case "login": {
+            const env = text("env") || "production";
+            const method = text("method") || "browser";
+            const loginContext = await resolveContext({
+                flags: {
+                    env,
+                    profile: context.profile,
+                    timeout: String(context.timeoutMs),
+                },
+            });
+            const identity = createClients(loginContext).identity;
+            if (method === "token") {
+                const token = text("token");
+                if (!token)
+                    return { error: "Token required (open advanced)" };
+                await loginWithToken(loginContext, token);
+            }
+            else if (method === "email") {
+                const email = text("email");
+                if (!email)
+                    return { error: "Email required (open advanced)" };
+                const otp = text("otp");
+                if (!otp) {
+                    await requestOtp(identity, email);
+                    return {
+                        error: "OTP sent — re-open /login, set method=email, fill email+otp in advanced",
+                    };
+                }
+                await loginWithOtp(loginContext, identity, email, otp);
+            }
+            else {
+                await loginWithBrowser(loginContext, PLAYGROUND_URLS[loginContext.environment]);
+            }
+            return {
+                toast: `Logged in to ${loginContext.environment}`,
+                refreshScope: true,
+                jumpTab: "scope",
+            };
+        }
+        case "pull": {
+            const tag = text("tag");
+            const dir = text("dir");
+            const force = values.force === true;
+            try {
+                const result = await pullBundle(context, clients.management, {
+                    ...(tag && tag !== "latest" ? { tag } : {}),
+                    ...(dir ? { destination: dir } : {}),
+                    force,
+                });
+                const removed = result.removed.length
+                    ? ` · removed ${result.removed.length}`
+                    : "";
+                return {
+                    jumpTab: "bundle",
+                    toast: `Pulled ${Object.keys(result.files).length} file(s)${removed}`,
+                    refreshScope: true,
+                };
+            }
+            catch (error) {
+                if (!force &&
+                    error instanceof ConfigError &&
+                    (error.suggestion?.includes("--force") ||
+                        /changed|baseline/i.test(error.message))) {
+                    return {
+                        jumpTab: "bundle",
+                        needConfirm: {
+                            title: "force pull (discard local changes)",
+                            phrase: "force",
+                            action: "pull-force",
+                            args: {
+                                ...(tag ? { tag } : {}),
+                                ...(dir ? { dir } : {}),
+                            },
+                        },
+                        toast: error.message.split("\n")[0],
+                    };
+                }
+                throw error;
+            }
+        }
+        case "push": {
+            const message = text("message");
+            const dryRun = values.dryRun === true;
+            const result = await pushBundle(context, clients.management, clients.runtime, {
+                ...(message ? { commitMessage: message } : {}),
+                dryRun,
+            });
+            return {
+                jumpTab: "bundle",
+                toast: result.push
+                    ? `Pushed ${result.push.new_version_tag} · ${diffSummary(result.diff)}`
+                    : `Dry run · ${diffSummary(result.diff)}`,
+                refreshScope: true,
+            };
+        }
+        case "provision": {
+            const provisioned = await provisionMockDb(context);
+            let note = `Provisioned mock DB for ${provisioned.agentId ?? "agent"}`;
+            if (values.wire === true) {
+                const wired = await wireMockDbConnection(context);
+                note += ` · wired ${wired.connectionId}`;
+            }
+            return { jumpTab: "mockdb", toast: note };
+        }
+        case "seed": {
+            const collection = text("collection");
+            const rowsRaw = parseJsonFlag("--rows", text("rows"));
+            const rows = Array.isArray(rowsRaw) ? rowsRaw : [rowsRaw];
+            await seedRows(context, collection, rows);
+            return { jumpTab: "mockdb", toast: `Seeded ${collection}` };
+        }
+        case "mdb-collection-create": {
+            const schema = normalizeSchema(parseJsonFlag("--schema", text("schema")));
+            await createCollection(context, text("name"), schema);
+            return {
+                jumpTab: "mockdb",
+                toast: `Created collection ${text("name")}`,
+            };
+        }
+        case "mdb-collection-update": {
+            const raw = parseJsonFlag("--add-columns", text("addColumns"));
+            const addColumns = Array.isArray(raw)
+                ? raw
+                : (raw.columns ?? []);
+            if (!Array.isArray(addColumns) || addColumns.length === 0) {
+                return { error: "addColumns must be a non-empty JSON array" };
+            }
+            await updateCollection(context, text("name"), addColumns);
+            return {
+                jumpTab: "mockdb",
+                toast: `Updated collection ${text("name")}`,
+            };
+        }
+        case "mdb-endpoint-create": {
+            const body = parseJsonFlag("--body", text("body"));
+            if (!body || typeof body !== "object" || Array.isArray(body)) {
+                return { error: "body must be a JSON object" };
+            }
+            await createEndpoint(context, body);
+            return { jumpTab: "mockdb", toast: "Created endpoint" };
+        }
+        case "mdb-endpoint-update": {
+            const body = parseJsonFlag("--body", text("body"));
+            await updateEndpoint(context, text("slug"), body);
+            return {
+                jumpTab: "mockdb",
+                toast: `Updated endpoint ${text("slug")}`,
+            };
+        }
+        case "mdb-endpoint-get": {
+            const ep = await getEndpoint(context, text("slug"));
+            return {
+                jumpTab: "mockdb",
+                paneTitle: `endpoint ${text("slug")}`,
+                paneLines: [JSON.stringify(ep, null, 2)],
+            };
+        }
+        case "mdb-endpoint-execute": {
+            const bodyRaw = text("body");
+            const body = bodyRaw
+                ? parseJsonFlag("--body", bodyRaw)
+                : undefined;
+            const result = await executeEndpoint(context, text("slug"), {
+                ...(text("session") ? { session: text("session") } : {}),
+                ...(body !== undefined ? { body } : {}),
+            });
+            return {
+                jumpTab: "mockdb",
+                paneTitle: `execute ${text("slug")}`,
+                paneLines: [JSON.stringify(result, null, 2)],
+                toast: `Executed ${text("slug")}`,
+            };
+        }
+        case "mdb-endpoint-delete": {
+            const slug = text("slug");
+            if (!slug)
+                return { error: "slug required" };
+            return {
+                jumpTab: "mockdb",
+                needConfirm: {
+                    title: `delete endpoint ${slug}`,
+                    phrase: slug,
+                    action: "mdb-endpoint-delete",
+                    args: { slug },
+                },
+            };
+        }
+        case "workspace-create": {
+            const root = text("path");
+            const name = text("name");
+            const result = await enterWorkspace(context, root, {
+                create: true,
+                ...(name ? { name } : {}),
+            });
+            return {
+                toast: `Created and entered ${result.path}`,
+                refreshScope: true,
+                jumpTab: "scope",
+            };
+        }
+        case "project-create": {
+            const result = await createProject(context, clients.management, text("name"), process.cwd());
+            return {
+                toast: `Created project ${result.project.name}`,
+                refreshScope: true,
+                jumpTab: "scope",
+            };
+        }
+        case "agent-create": {
+            if (!text("dir") && !context.workspaceRoot) {
+                return { error: "No workspace — pass dir or run from a workspace" };
+            }
+            const created = await createAgent(context, clients.management, text("name"));
+            let relative;
+            let directory;
+            if (text("dir")) {
+                directory = path.resolve(text("dir"));
+                relative = context.workspaceRoot
+                    ? relativeWorkspacePath(context.workspaceRoot, directory)
+                    : undefined;
+            }
+            else {
+                const allocated = await allocateAgentDirectory(context.workspaceRoot, created.name, created.id);
+                directory = allocated.absolute;
+                relative = allocated.relative;
+            }
+            const sourceDirectory = path.join(directory, "bundle", "src");
+            await mkdir(sourceDirectory, { recursive: true });
+            await bindAgent(context, created, directory);
+            const slug = text("name")
+                .toLowerCase()
+                .replace(/[^a-z0-9]+/g, "-")
+                .replace(/^-|-$/g, "") || "agent";
+            await writeFile(path.join(sourceDirectory, "program.yaml"), `id: ${slug}\nversion: 0.1.0\n`, { encoding: "utf8", flag: "wx" }).catch((error) => {
+                if (error.code !== "EEXIST")
+                    throw error;
+            });
+            if (context.workspaceRoot && relative) {
+                await registerAgent(context.workspaceRoot, {
+                    agent_id: created.id,
+                    name: created.name,
+                    path: relative,
+                });
+            }
+            return {
+                toast: `Created ${created.name} in ${directory}`,
+                refreshScope: true,
+                jumpTab: "scope",
+            };
+        }
+        case "agent-import": {
+            const agentId = text("agent");
+            if (!agentId)
+                return { error: "Agent required" };
+            if (!text("dir") && !context.workspaceRoot) {
+                return { error: "No workspace — pass dir or run from a workspace" };
+            }
+            const agent = await clients.management.getAgent(agentId);
+            let relative;
+            let destination;
+            if (text("dir")) {
+                destination = path.resolve(text("dir"));
+                relative = context.workspaceRoot
+                    ? relativeWorkspacePath(context.workspaceRoot, destination)
+                    : undefined;
+            }
+            else {
+                const allocated = await allocateAgentDirectory(context.workspaceRoot, agent.name, agent.id);
+                destination = allocated.absolute;
+                relative = allocated.relative;
+            }
+            const imported = await importBundle(context, clients.management, agentId, destination, text("tag") || undefined);
+            await installSkills(clients.runtime, destination, ["cursor", "claude"]);
+            if (context.workspaceRoot && relative) {
+                await registerAgent(context.workspaceRoot, {
+                    agent_id: agent.id,
+                    name: agent.name,
+                    path: relative,
+                });
+            }
+            return {
+                toast: `Imported ${Object.keys(imported.files).length} files into ${destination}`,
+                refreshScope: true,
+                jumpTab: "scope",
+            };
+        }
+        case "var":
+            return { toast: "var handled by UI" };
+        default:
+            return { error: `Sheet /${commandName} not wired` };
+    }
+}
+export async function runDestructive(action, context, args = {}) {
+    const clients = createClients(context);
+    switch (action) {
+        case "logout": {
+            if (context.token) {
+                await clients.identity.logout().catch(() => undefined);
+            }
+            await logoutSession(context);
+            return {
+                toast: "Logged out",
+                refreshScope: true,
+                jumpTab: "scope",
+            };
+        }
+        case "agent-unlink": {
+            if (context.workspaceRoot &&
+                (context.bindingFromWorkspace || !context.bindingPath)) {
+                await clearActiveAgent(context.workspaceRoot);
+                return {
+                    toast: "Cleared active workspace agent",
+                    refreshScope: true,
+                    jumpTab: "scope",
+                };
+            }
+            if (!context.bindingPath) {
+                return { error: "No .apollorc bound here" };
+            }
+            await unlinkAgent(context, process.cwd());
+            return {
+                toast: "Unlinked local agent binding",
+                refreshScope: true,
+                jumpTab: "scope",
+            };
+        }
+        case "mdb-rotate-mgmt": {
+            await rotateMgmtKey(context);
+            return { jumpTab: "mockdb", toast: "Rotated management key" };
+        }
+        case "mdb-rotate-runtime": {
+            await rotateRuntimeKey(context);
+            return { jumpTab: "mockdb", toast: "Rotated runtime key" };
+        }
+        case "mdb-delete": {
+            await deleteMockDb(context);
+            return { jumpTab: "mockdb", toast: "Deleted mock DB" };
+        }
+        case "pull-force": {
+            const tag = args.tag ?? "";
+            const dir = args.dir ?? "";
+            const result = await pullBundle(context, clients.management, {
+                ...(tag && tag !== "latest" ? { tag } : {}),
+                ...(dir ? { destination: dir } : {}),
+                force: true,
+            });
+            const removed = result.removed.length
+                ? ` · removed ${result.removed.length}`
+                : "";
+            return {
+                jumpTab: "bundle",
+                toast: `Force-pulled ${Object.keys(result.files).length} file(s)${removed}`,
+                refreshScope: true,
+            };
+        }
+        case "mdb-endpoint-delete": {
+            await deleteEndpoint(context, args.slug ?? "");
+            return {
+                jumpTab: "mockdb",
+                toast: `Deleted endpoint ${args.slug ?? ""}`,
+            };
+        }
+        case "version-publish":
+        case "version-archive":
+            return applyPick(action, args.id ?? "", context);
+        default:
+            return { error: `Unknown confirm action ${action}` };
+    }
+}
+export function destructiveSpec(commandName, context) {
+    switch (commandName) {
+        case "logout":
+            return { title: "logout", phrase: "logout", action: "logout" };
+        case "agent-unlink":
+            return {
+                title: "unlink agent",
+                phrase: "unlink",
+                action: "agent-unlink",
+            };
+        case "mdb-rotate-mgmt":
+            return {
+                title: "rotate mgmt key",
+                phrase: "rotate",
+                action: "mdb-rotate-mgmt",
+            };
+        case "mdb-rotate-runtime":
+            return {
+                title: "rotate runtime key",
+                phrase: "rotate",
+                action: "mdb-rotate-runtime",
+            };
+        case "mdb-delete":
+            return {
+                title: "delete mock DB",
+                phrase: context.agentId?.slice(0, 8) ?? "delete",
+                action: "mdb-delete",
+            };
+        default:
+            return undefined;
+    }
+}
+/** Resolve chat overlay for bare `t` / `d` / `t N` / `d N` on the Chat tab. */
+export async function chatOverlay(kind, chat, threadId, context, indexArg) {
+    const agentTurns = chat
+        .map((turn, index) => ({ turn, index }))
+        .filter((entry) => entry.turn.role === "agent");
+    if (agentTurns.length === 0) {
+        return { error: "No agent replies yet — send a message first" };
+    }
+    let pick = agentTurns[agentTurns.length - 1];
+    if (indexArg?.trim()) {
+        const n = Number(indexArg.trim());
+        if (!Number.isInteger(n) || n < 1 || n > agentTurns.length) {
+            return {
+                error: `Pick agent reply 1–${agentTurns.length} (oldest→newest)`,
+            };
+        }
+        pick = agentTurns[n - 1];
+    }
+    const clients = createClients(context);
+    if (kind === "trace") {
+        if (pick.turn.trace) {
+            return {
+                jumpTab: "chat",
+                paneTitle: `trace · turn ${pick.index + 1}`,
+                paneLines: [JSON.stringify(pick.turn.trace, null, 2)],
+                toast: "Trace (from reply)",
+            };
+        }
+        if (threadId) {
+            const data = await fetchTrace(clients.runtime, threadId, pick.turn.interactionId);
+            return {
+                jumpTab: "chat",
+                paneTitle: `trace · ${pick.turn.interactionId ?? threadId.slice(0, 12)}`,
+                paneLines: [JSON.stringify(data, null, 2)],
+                toast: "Trace loaded",
+            };
+        }
+        return {
+            error: "No trace on this reply — enable /trace before sending, or open a /thread",
+        };
+    }
+    const interactionId = pick.turn.interactionId ?? pick.turn.messageId;
+    if (!interactionId) {
+        return { error: "No interaction id on this reply" };
+    }
+    const data = await debugInteraction(clients.runtime, interactionId);
+    return {
+        jumpTab: "chat",
+        paneTitle: `debug · ${interactionId.slice(0, 12)}`,
+        paneLines: [JSON.stringify(data, null, 2)],
+        toast: "Debug loaded",
+    };
+}
+//# sourceMappingURL=actions.js.map