agent-office 0.0.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Richard Anaya
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,170 @@
+# agent-office
+
+Manage [OpenCode](https://opencode.ai) sessions with named aliases, agent codes, and a full-screen terminal UI.
+
+## Overview
+
+`agent-office` is a CLI tool with two main roles:
+
+- **`serve`** — runs an HTTP server that sits in front of an OpenCode server and a PostgreSQL database. It manages named sessions, agent codes, and exposes a REST API.
+- **`manage`** — a full-screen React Ink TUI that connects to a running `serve` instance and lets you create, delete, inspect, and interact with sessions.
+- **`worker clock-in`** — lets an agent identify itself using its unique agent code and receive a welcome message with its session details.
+
+## Installation
+
+```bash
+npm install -g agent-office
+```
+
+Or run without installing:
+
+```bash
+npx agent-office serve --help
+```
+
+## Requirements
+
+- Node.js >= 18
+- A running [OpenCode](https://opencode.ai) server (`opencode serve`)
+- A PostgreSQL database
+
+## Quick Start
+
+### 1. Start the server
+
+```bash
+agent-office serve \
+  --database-url "postgresql://user:pass@localhost:5432/mydb" \
+  --opencode-url "http://localhost:4096" \
+  --host 127.0.0.1 \
+  --port 7654 \
+  --password mysecret
+```
+
+Or use environment variables:
+
+```bash
+export DATABASE_URL="postgresql://user:pass@localhost:5432/mydb"
+export AGENT_OFFICE_PASSWORD="mysecret"
+agent-office serve
+```
+
+### 2. Open the manager
+
+```bash
+agent-office manage http://localhost:7654 --password mysecret
+```
+
+### 3. Clock in as a worker
+
+```bash
+agent-office worker clock-in <agent_code>@http://localhost:7654
+```
+
+## Environment Variables
+
+Copy `.env.example` to `.env` for local development:
+
+```bash
+cp .env.example .env
+```
+
+| Variable | Description |
+|---|---|
+| `DATABASE_URL` | PostgreSQL connection string |
+| `AGENT_OFFICE_PASSWORD` | Password for the server API (required) |
+| `OPENCODE_URL` | OpenCode server URL (default: `http://localhost:4096`) |
+
+## Commands
+
+### `agent-office serve`
+
+Starts the HTTP server. Runs database migrations automatically on startup.
+
+```
+Options:
+  --database-url <url>   PostgreSQL connection string (env: DATABASE_URL)
+  --opencode-url <url>   OpenCode server URL (env: OPENCODE_URL)
+  --host <host>          Host to bind to (default: 127.0.0.1)
+  --port <port>          Port to serve on (default: 7654)
+  --password <password>  REQUIRED. API password (env: AGENT_OFFICE_PASSWORD)
+```
+
+### `agent-office manage <url>`
+
+Opens the full-screen terminal UI. All operations go through the server — `manage` never touches the database or OpenCode directly.
+
+```
+Arguments:
+  url                    URL of the agent-office server
+
+Options:
+  --password <password>  REQUIRED. API password (env: AGENT_OFFICE_PASSWORD)
+```
+
+#### TUI screens
+
+| Screen | Description |
+|---|---|
+| List sessions | View all named sessions with masked agent codes. `↑↓` to navigate, `r` to reveal/hide the selected session's agent code |
+| Create session | Create a new named session. Automatically creates an OpenCode session and generates an agent code |
+| Delete session | Select and delete a session (also deletes the OpenCode session) |
+| Tail messages | View the most recent messages in a session |
+| Inject text | Send a message into a session |
+| Agent code | Reveal, hide, or regenerate the agent code for a session |
+
+### `agent-office worker clock-in <token>`
+
+Clock in as a named agent. No password required — authentication is via the agent code.
+
+```bash
+agent-office worker clock-in <agent_code>@<server-url>
+
+# Example
+agent-office worker clock-in 550e8400-e29b-41d4-a716-446655440000@http://localhost:7654
+```
+
+On success, prints:
+
+```
+Welcome to the agent office, your name is john. Your OpenCode session ID is <id>. You are now clocked in and ready to work.
+```
+
+## REST API
+
+All endpoints except `/worker/clock-in` require `Authorization: Bearer <password>`.
+
+| Method | Path | Description |
+|---|---|---|
+| `GET` | `/health` | Health check |
+| `GET` | `/sessions` | List all sessions |
+| `POST` | `/sessions` | Create session `{ name }` |
+| `DELETE` | `/sessions/:name` | Delete session by name |
+| `GET` | `/sessions/:name/messages` | Fetch recent messages (`?limit=N`, max 100) |
+| `POST` | `/sessions/:name/inject` | Inject text `{ text, modelID?, providerID? }` |
+| `POST` | `/sessions/:name/regenerate-code` | Regenerate agent code |
+| `GET` | `/worker/clock-in?code=<uuid>` | Validate agent code (no auth) |
+
+## Development
+
+```bash
+# Install dependencies
+npm install
+
+# Copy env
+cp .env.example .env
+# Edit .env with your values
+
+# Run server
+npm run dev:serve -- --password secret
+
+# Run manager (in another terminal)
+npm run dev:manage -- http://localhost:7654 --password secret
+
+# Build
+npm run build
+```
+
+## License
+
+MIT © Richard Anaya

package/dist/cli.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+import "dotenv/config";

package/dist/cli.js

@@ -0,0 +1,41 @@
+#!/usr/bin/env node
+import "dotenv/config";
+import { Command } from "commander";
+const program = new Command();
+program
+    .name("agent-office")
+    .description("Manage OpenCode sessions with named aliases")
+    .version("0.1.0");
+program
+    .command("serve")
+    .description("Start the agent-office HTTP server")
+    .option("--database-url <url>", "PostgreSQL connection string", process.env.DATABASE_URL)
+    .option("--opencode-url <url>", "OpenCode server URL", process.env.OPENCODE_URL ?? "http://localhost:4096")
+    .option("--host <host>", "Host to bind to", "127.0.0.1")
+    .option("--port <port>", "Port to serve on", "7654")
+    .option("--password <password>", "REQUIRED. API password", process.env.AGENT_OFFICE_PASSWORD)
+    .action(async (options) => {
+    const { serve } = await import("./commands/serve.js");
+    await serve(options);
+});
+program
+    .command("manage")
+    .description("Launch the interactive TUI to manage sessions")
+    .argument("<url>", "URL of the agent-office server (e.g. http://localhost:7654)")
+    .option("--password <password>", "REQUIRED. API password", process.env.AGENT_OFFICE_PASSWORD)
+    .action(async (url, options) => {
+    const { manage } = await import("./commands/manage.js");
+    await manage(url, options);
+});
+const workerCmd = program
+    .command("worker")
+    .description("Worker agent commands");
+workerCmd
+    .command("clock-in")
+    .description("Clock in as a worker agent")
+    .argument("<token>", "Agent token in the format <agent_code>@<server-url>")
+    .action(async (token) => {
+    const { clockIn } = await import("./commands/worker.js");
+    await clockIn(token);
+});
+program.parse();

package/dist/commands/manage.d.ts

@@ -0,0 +1,5 @@
+interface ManageOptions {
+    password?: string;
+}
+export declare function manage(url: string, options: ManageOptions): Promise<void>;
+export {};

package/dist/commands/manage.js

@@ -0,0 +1,20 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { render } from "ink";
+import { App } from "../manage/app.js";
+export async function manage(url, options) {
+    const password = options.password;
+    if (!password) {
+        console.error("Error: --password is required (or set AGENT_OFFICE_PASSWORD)");
+        process.exit(1);
+    }
+    // Validate the URL minimally
+    try {
+        new URL(url);
+    }
+    catch {
+        console.error(`Error: invalid server URL "${url}"`);
+        process.exit(1);
+    }
+    const { waitUntilExit } = render(_jsx(App, { serverUrl: url, password: password }));
+    await waitUntilExit();
+}

package/dist/commands/serve.d.ts

@@ -0,0 +1,9 @@
+interface ServeOptions {
+    databaseUrl?: string;
+    opencodeUrl: string;
+    host: string;
+    port: string;
+    password?: string;
+}
+export declare function serve(options: ServeOptions): Promise<void>;
+export {};

package/dist/commands/serve.js

@@ -0,0 +1,54 @@
+import { createDb } from "../db/index.js";
+import { runMigrations } from "../db/migrate.js";
+import { createOpencodeClient } from "../lib/opencode.js";
+import { createApp } from "../server/index.js";
+export async function serve(options) {
+    const password = options.password;
+    if (!password) {
+        console.error("Error: --password is required (or set AGENT_OFFICE_PASSWORD)");
+        process.exit(1);
+    }
+    const databaseUrl = options.databaseUrl;
+    if (!databaseUrl) {
+        console.error("Error: --database-url is required (or set DATABASE_URL)");
+        process.exit(1);
+    }
+    const port = parseInt(options.port, 10);
+    if (isNaN(port) || port < 1 || port > 65535) {
+        console.error(`Error: invalid port "${options.port}"`);
+        process.exit(1);
+    }
+    // Connect to DB
+    console.log("Connecting to database...");
+    const sql = createDb(databaseUrl);
+    // Run migrations
+    console.log("Running migrations...");
+    try {
+        await runMigrations(sql);
+        console.log("Migrations complete.");
+    }
+    catch (err) {
+        console.error("Migration failed:", err);
+        await sql.end();
+        process.exit(1);
+    }
+    // Init OpenCode client
+    const opencode = createOpencodeClient(options.opencodeUrl);
+    // Create Express app
+    const app = createApp(sql, opencode, password);
+    // Start server
+    const server = app.listen(port, options.host, () => {
+        console.log(`agent-office server listening on http://${options.host}:${port}`);
+    });
+    // Graceful shutdown
+    const shutdown = async () => {
+        console.log("\nShutting down...");
+        server.close(async () => {
+            await sql.end();
+            console.log("Goodbye.");
+            process.exit(0);
+        });
+    };
+    process.on("SIGINT", shutdown);
+    process.on("SIGTERM", shutdown);
+}

package/dist/commands/worker.d.ts

@@ -0,0 +1 @@
+export declare function clockIn(token: string): Promise<void>;

package/dist/commands/worker.js

@@ -0,0 +1,50 @@
+// UUID v4 pattern
+const UUID_RE = /^[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i;
+export async function clockIn(token) {
+    // Parse <agent_code>@<url>  — URL may contain @ itself (unlikely but safe with lastIndexOf)
+    const atIndex = token.indexOf("@");
+    if (atIndex === -1) {
+        console.error("Error: token must be in the format <agent_code>@<server-url>");
+        console.error("Example: 550e8400-e29b-41d4-a716-446655440000@http://localhost:7654");
+        process.exit(1);
+    }
+    const agentCode = token.slice(0, atIndex);
+    const serverUrl = token.slice(atIndex + 1);
+    if (!UUID_RE.test(agentCode)) {
+        console.error(`Error: "${agentCode}" is not a valid UUID agent code`);
+        process.exit(1);
+    }
+    let parsedUrl;
+    try {
+        parsedUrl = new URL(serverUrl);
+    }
+    catch {
+        console.error(`Error: "${serverUrl}" is not a valid URL`);
+        process.exit(1);
+    }
+    const clockInUrl = `${parsedUrl.origin}/worker/clock-in?code=${encodeURIComponent(agentCode)}`;
+    let res;
+    try {
+        res = await fetch(clockInUrl);
+    }
+    catch (err) {
+        console.error(`Error: could not reach ${parsedUrl.origin}`);
+        console.error(err instanceof Error ? err.message : String(err));
+        process.exit(1);
+    }
+    let body;
+    try {
+        body = await res.json();
+    }
+    catch {
+        console.error(`Error: invalid response from server`);
+        process.exit(1);
+    }
+    if (!res.ok) {
+        const msg = body.error ?? `HTTP ${res.status}`;
+        console.error(`Error: ${msg}`);
+        process.exit(1);
+    }
+    const { message } = body;
+    console.log(message);
+}

package/dist/db/index.d.ts

@@ -0,0 +1,10 @@
+import postgres from "postgres";
+export type Sql = ReturnType<typeof postgres>;
+export declare function createDb(databaseUrl: string): Sql;
+export interface SessionRow {
+    id: number;
+    name: string;
+    session_id: string;
+    agent_code: string;
+    created_at: Date;
+}

package/dist/db/index.js

@@ -0,0 +1,9 @@
+import postgres from "postgres";
+export function createDb(databaseUrl) {
+    return postgres(databaseUrl, {
+        max: 10,
+        idle_timeout: 30,
+        connect_timeout: 10,
+        onnotice: () => { },
+    });
+}

package/dist/db/migrate.d.ts

@@ -0,0 +1,2 @@
+import type { Sql } from "./index.js";
+export declare function runMigrations(sql: Sql): Promise<void>;

package/dist/db/migrate.js

@@ -0,0 +1,45 @@
+const MIGRATIONS = [
+    {
+        version: 1,
+        name: "create_sessions",
+        sql: `
+      CREATE TABLE IF NOT EXISTS sessions (
+        id         SERIAL PRIMARY KEY,
+        name       VARCHAR(255) UNIQUE NOT NULL,
+        session_id VARCHAR(255) UNIQUE NOT NULL,
+        created_at TIMESTAMPTZ NOT NULL DEFAULT NOW()
+      );
+      CREATE INDEX IF NOT EXISTS idx_sessions_name ON sessions(name);
+    `,
+    },
+    {
+        version: 2,
+        name: "add_agent_code",
+        sql: `
+      ALTER TABLE sessions ADD COLUMN IF NOT EXISTS agent_code UUID NOT NULL DEFAULT gen_random_uuid();
+      CREATE UNIQUE INDEX IF NOT EXISTS idx_sessions_agent_code ON sessions(agent_code);
+    `,
+    },
+];
+export async function runMigrations(sql) {
+    await sql `
+    CREATE TABLE IF NOT EXISTS _migrations (
+      version    INTEGER PRIMARY KEY,
+      name       VARCHAR(255) NOT NULL,
+      applied_at TIMESTAMPTZ NOT NULL DEFAULT NOW()
+    )
+  `;
+    const applied = await sql `
+    SELECT version FROM _migrations ORDER BY version
+  `;
+    const appliedVersions = new Set(applied.map((r) => r.version));
+    for (const migration of MIGRATIONS) {
+        if (appliedVersions.has(migration.version))
+            continue;
+        console.log(`  Applying migration ${migration.version}: ${migration.name}`);
+        await sql.begin(async (tx) => {
+            await tx.unsafe(migration.sql);
+            await tx.unsafe(`INSERT INTO _migrations (version, name) VALUES ($1, $2)`, [migration.version, migration.name]);
+        });
+    }
+}

package/dist/lib/opencode.d.ts

@@ -0,0 +1,7 @@
+import Opencode from "@opencode-ai/sdk";
+export type OpencodeClient = InstanceType<typeof Opencode>;
+export declare function createOpencodeClient(baseURL: string): OpencodeClient;
+export interface OpencodeSession {
+    id: string;
+    title?: string;
+}

package/dist/lib/opencode.js

@@ -0,0 +1,4 @@
+import Opencode from "@opencode-ai/sdk";
+export function createOpencodeClient(baseURL) {
+    return new Opencode({ baseURL });
+}

package/dist/manage/app.d.ts

@@ -0,0 +1,6 @@
+interface AppProps {
+    serverUrl: string;
+    password: string;
+}
+export declare function App({ serverUrl, password }: AppProps): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/manage/app.js

@@ -0,0 +1,102 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { useState, useEffect } from "react";
+import { Box, Text, useApp, useStdout, useInput } from "ink";
+import { Select, Spinner } from "@inkjs/ui";
+import { useApi } from "./hooks/useApi.js";
+import { SessionList } from "./components/SessionList.js";
+import { CreateSession } from "./components/CreateSession.js";
+import { DeleteSession } from "./components/DeleteSession.js";
+import { TailMessages } from "./components/TailMessages.js";
+import { InjectText } from "./components/InjectText.js";
+import { AgentCode } from "./components/AgentCode.js";
+const MENU_OPTIONS = [
+    { label: "List sessions", value: "list" },
+    { label: "Create session", value: "create" },
+    { label: "Delete session", value: "delete" },
+    { label: "Tail messages", value: "tail" },
+    { label: "Inject text", value: "inject" },
+    { label: "Agent code", value: "agent-code" },
+    { label: "Quit", value: "quit" },
+];
+const SUB_SCREENS = ["list", "create", "delete", "tail", "inject", "agent-code"];
+const FOOTER_HINTS = {
+    connecting: "",
+    "auth-error": "",
+    menu: "↑↓ navigate · Enter select · q quit",
+    list: "↑↓ navigate · r reveal/hide agent code · Esc back to menu",
+    create: "Enter submit · Esc back to menu",
+    delete: "↑↓ navigate · Enter select · Esc back to menu",
+    tail: "↑↓ scroll · Esc back to menu",
+    inject: "Enter submit · Esc back to menu",
+    "agent-code": "r reveal/hide · g regenerate · Esc back to menu",
+};
+function Header({ serverUrl }) {
+    return (_jsxs(Box, { borderStyle: "single", borderColor: "cyan", paddingX: 1, justifyContent: "space-between", children: [_jsx(Text, { bold: true, color: "cyan", children: "agent-office" }), _jsx(Text, { dimColor: true, children: serverUrl })] }));
+}
+function Footer({ hint }) {
+    return (_jsx(Box, { borderStyle: "single", borderColor: "gray", paddingX: 1, children: _jsx(Text, { dimColor: true, children: hint }) }));
+}
+export function App({ serverUrl, password }) {
+    const { exit } = useApp();
+    const { stdout } = useStdout();
+    const { checkHealth } = useApi(serverUrl, password);
+    const [screen, setScreen] = useState("connecting");
+    const [termHeight, setTermHeight] = useState(stdout?.rows ?? 24);
+    const [termWidth, setTermWidth] = useState(stdout?.columns ?? 80);
+    // Track terminal size
+    useEffect(() => {
+        const update = () => {
+            setTermHeight(stdout?.rows ?? 24);
+            setTermWidth(stdout?.columns ?? 80);
+        };
+        stdout?.on("resize", update);
+        return () => { stdout?.off("resize", update); };
+    }, [stdout]);
+    // Health check on mount
+    useEffect(() => {
+        checkHealth().then((ok) => {
+            setScreen(ok ? "menu" : "auth-error");
+        });
+    }, []);
+    useInput((input, key) => {
+        if (key.escape && SUB_SCREENS.includes(screen)) {
+            setScreen("menu");
+        }
+        if (input === "q" && screen === "menu") {
+            exit();
+        }
+    });
+    const goBack = () => setScreen("menu");
+    const handleMenuSelect = (value) => {
+        if (value === "quit") {
+            exit();
+            return;
+        }
+        setScreen(value);
+    };
+    // content area = terminal height minus header (3 rows) and footer (3 rows)
+    const contentHeight = Math.max(4, termHeight - 6);
+    const renderContent = () => {
+        switch (screen) {
+            case "connecting":
+                return (_jsx(Box, { height: contentHeight, alignItems: "center", justifyContent: "center", children: _jsx(Spinner, { label: `Connecting to ${serverUrl}...` }) }));
+            case "auth-error":
+                return (_jsxs(Box, { height: contentHeight, flexDirection: "column", alignItems: "center", justifyContent: "center", gap: 1, children: [_jsx(Text, { color: "red", bold: true, children: "Connection failed" }), _jsxs(Text, { children: ["Could not reach ", _jsx(Text, { color: "cyan", children: serverUrl })] }), _jsx(Text, { dimColor: true, children: "Check that agent-office serve is running and your --password is correct." })] }));
+            case "menu":
+                return (_jsxs(Box, { height: contentHeight, flexDirection: "column", paddingX: 2, paddingY: 1, gap: 1, children: [_jsx(Text, { bold: true, children: "Main Menu" }), _jsx(Select, { options: MENU_OPTIONS, onChange: handleMenuSelect })] }));
+            case "list":
+                return (_jsx(Box, { height: contentHeight, flexDirection: "column", paddingX: 2, paddingY: 1, children: _jsx(SessionList, { serverUrl: serverUrl, password: password, onBack: goBack, contentHeight: contentHeight - 2 }) }));
+            case "create":
+                return (_jsx(Box, { height: contentHeight, flexDirection: "column", paddingX: 2, paddingY: 1, children: _jsx(CreateSession, { serverUrl: serverUrl, password: password, onBack: goBack }) }));
+            case "delete":
+                return (_jsx(Box, { height: contentHeight, flexDirection: "column", paddingX: 2, paddingY: 1, children: _jsx(DeleteSession, { serverUrl: serverUrl, password: password, onBack: goBack }) }));
+            case "tail":
+                return (_jsx(Box, { height: contentHeight, flexDirection: "column", paddingX: 2, paddingY: 1, children: _jsx(TailMessages, { serverUrl: serverUrl, password: password, onBack: goBack, contentHeight: contentHeight - 2 }) }));
+            case "inject":
+                return (_jsx(Box, { height: contentHeight, flexDirection: "column", paddingX: 2, paddingY: 1, children: _jsx(InjectText, { serverUrl: serverUrl, password: password, onBack: goBack, contentHeight: contentHeight - 2 }) }));
+            case "agent-code":
+                return (_jsx(Box, { height: contentHeight, flexDirection: "column", paddingX: 2, paddingY: 1, children: _jsx(AgentCode, { serverUrl: serverUrl, password: password, onBack: goBack, contentHeight: contentHeight - 2 }) }));
+        }
+    };
+    return (_jsxs(Box, { flexDirection: "column", width: termWidth, children: [_jsx(Header, { serverUrl: serverUrl }), renderContent(), screen !== "connecting" && (_jsx(Footer, { hint: FOOTER_HINTS[screen] }))] }));
+}

package/dist/manage/components/AgentCode.d.ts

@@ -0,0 +1,8 @@
+interface AgentCodeProps {
+    serverUrl: string;
+    password: string;
+    onBack: () => void;
+    contentHeight: number;
+}
+export declare function AgentCode({ serverUrl, password, onBack, contentHeight }: AgentCodeProps): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/manage/components/AgentCode.js

@@ -0,0 +1,73 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { useEffect, useState } from "react";
+import { Box, Text, useInput } from "ink";
+import { Select, Spinner, ConfirmInput } from "@inkjs/ui";
+import { useApi, useAsyncState } from "../hooks/useApi.js";
+const MASKED = "••••••••-••••-••••-••••-••••••••••••";
+export function AgentCode({ serverUrl, password, onBack, contentHeight }) {
+    const { listSessions, regenerateCode } = useApi(serverUrl, password);
+    const { run: runList } = useAsyncState();
+    const [sessions, setSessions] = useState([]);
+    const [stage, setStage] = useState("loading-sessions");
+    const [selected, setSelected] = useState(null);
+    const [revealed, setRevealed] = useState(false);
+    const [error, setError] = useState(null);
+    useEffect(() => {
+        runList(listSessions).then((rows) => {
+            setSessions(rows ?? []);
+            setStage("select");
+        });
+    }, []);
+    // r = reveal/hide, g = trigger regenerate, when viewing
+    useInput((input) => {
+        if (stage !== "view")
+            return;
+        if (input === "r")
+            setRevealed((v) => !v);
+        if (input === "g")
+            setStage("confirm-regen");
+    });
+    const handleSelect = (name) => {
+        const session = sessions.find((s) => s.name === name) ?? null;
+        setSelected(session);
+        setRevealed(false);
+        setStage("view");
+    };
+    const handleConfirmRegen = async (confirmed) => {
+        if (!confirmed || !selected) {
+            setStage("view");
+            return;
+        }
+        setStage("regenerating");
+        try {
+            const updated = await regenerateCode(selected.name);
+            setSelected(updated);
+            setRevealed(true); // auto-reveal the new code
+            setStage("view");
+        }
+        catch (err) {
+            setError(err instanceof Error ? err.message : String(err));
+            setStage("error");
+        }
+    };
+    if (stage === "loading-sessions") {
+        return (_jsx(Box, { height: contentHeight, alignItems: "center", justifyContent: "center", children: _jsx(Spinner, { label: "Loading sessions..." }) }));
+    }
+    if (stage === "regenerating") {
+        return (_jsx(Box, { height: contentHeight, alignItems: "center", justifyContent: "center", children: _jsx(Spinner, { label: "Generating new agent code..." }) }));
+    }
+    if (stage === "error") {
+        return (_jsxs(Box, { flexDirection: "column", gap: 1, children: [_jsx(Text, { bold: true, children: "Agent Code" }), _jsxs(Text, { color: "red", children: ["Error: ", error] }), _jsx(Text, { dimColor: true, children: "Press Esc to go back" })] }));
+    }
+    if (stage === "select") {
+        if (sessions.length === 0) {
+            return (_jsx(Box, { height: contentHeight, alignItems: "center", justifyContent: "center", children: _jsx(Text, { dimColor: true, children: "No sessions yet. Create one first." }) }));
+        }
+        return (_jsxs(Box, { flexDirection: "column", gap: 1, children: [_jsx(Text, { bold: true, children: "Agent Code" }), _jsx(Text, { dimColor: true, children: "Select a session to view its agent code:" }), _jsx(Select, { options: sessions.map((s) => ({ label: s.name, value: s.name })), onChange: handleSelect })] }));
+    }
+    if (stage === "confirm-regen" && selected) {
+        return (_jsxs(Box, { flexDirection: "column", gap: 1, children: [_jsx(Text, { bold: true, children: "Agent Code" }), _jsxs(Text, { children: ["Regenerate code for ", _jsx(Text, { color: "cyan", bold: true, children: selected.name }), "?", " ", _jsx(Text, { dimColor: true, children: "The old code will stop working immediately." })] }), _jsx(ConfirmInput, { defaultChoice: "cancel", onConfirm: () => void handleConfirmRegen(true), onCancel: () => void handleConfirmRegen(false) })] }));
+    }
+    // stage === "view"
+    return (_jsxs(Box, { flexDirection: "column", gap: 1, children: [_jsxs(Box, { gap: 2, children: [_jsx(Text, { bold: true, children: "Agent Code" }), _jsx(Text, { color: "cyan", children: selected?.name })] }), _jsxs(Box, { gap: 2, marginY: 1, children: [_jsx(Text, { bold: true, children: "Code:" }), revealed ? (_jsx(Text, { color: "yellow", children: selected?.agent_code })) : (_jsx(Text, { dimColor: true, children: MASKED }))] }), _jsxs(Box, { gap: 2, children: [_jsx(Text, { dimColor: true, children: "Clock-in format:" }), _jsxs(Text, { dimColor: true, children: [revealed ? selected?.agent_code : MASKED, "@<server-url>"] })] }), _jsxs(Box, { flexDirection: "column", marginTop: 1, gap: 0, children: [_jsxs(Text, { dimColor: true, children: ["r  ", revealed ? "hide" : "reveal", " code"] }), _jsx(Text, { dimColor: true, children: "g  regenerate code" }), _jsx(Text, { dimColor: true, children: "Esc  back to menu" })] })] }));
+}