agent-kanban 1.0.0

package/dist/index.js

@@ -0,0 +1,265 @@
+#!/usr/bin/env node
+import { Command } from "commander";
+import { setConfigValue, getConfigValue } from "./config.js";
+import { ApiClient } from "./client.js";
+import { getFormat, output, formatTaskList, formatBoard, formatAgentList, formatBoardList, formatRepositoryList } from "./output.js";
+import { registerLinkCommand } from "./commands/link.js";
+import { registerStartCommand } from "./commands/start.js";
+const program = new Command();
+program.name("agent-kanban").description("Agent-first kanban board").version("1.3.0");
+// ─── Config ───
+const configCmd = program.command("config").description("Manage CLI configuration");
+configCmd
+    .command("set <key> <value>")
+    .description("Set a config value (api-url, api-key)")
+    .action((key, value) => {
+    setConfigValue(key, value);
+    console.log(`Set ${key}`);
+});
+configCmd
+    .command("get <key>")
+    .description("Get a config value")
+    .action((key) => {
+    const value = getConfigValue(key);
+    if (value)
+        console.log(value);
+    else {
+        console.error(`Not set: ${key}`);
+        process.exit(1);
+    }
+});
+// ─── Task ───
+const taskCmd = program.command("task").description("Manage tasks");
+taskCmd
+    .command("create")
+    .description("Create a new task")
+    .requiredOption("--title <title>", "Task title")
+    .option("--description <desc>", "Task description")
+    .option("--repo <repo>", "Repository name or ID")
+    .option("--priority <priority>", "Priority (low, medium, high, urgent)")
+    .option("--labels <labels>", "Comma-separated labels")
+    .option("--input <json>", "JSON input payload")
+    .option("--agent-name <name>", "Agent identity")
+    .option("--parent <id>", "Parent task ID (creates subtask)")
+    .option("--depends-on <ids>", "Comma-separated task IDs this depends on")
+    .option("--format <format>", "Output format (json, text)")
+    .action(async (opts) => {
+    const client = new ApiClient();
+    const body = { title: opts.title };
+    if (opts.description)
+        body.description = opts.description;
+    if (opts.repo)
+        body.repository_id = opts.repo;
+    if (opts.priority)
+        body.priority = opts.priority;
+    if (opts.labels)
+        body.labels = opts.labels.split(",").map((l) => l.trim());
+    if (opts.agentName)
+        body.agent_id = opts.agentName;
+    if (opts.parent)
+        body.created_from = opts.parent;
+    if (opts.dependsOn)
+        body.depends_on = opts.dependsOn.split(",").map((id) => id.trim());
+    if (opts.input) {
+        try {
+            body.input = JSON.parse(opts.input);
+        }
+        catch {
+            console.error("Invalid JSON for --input");
+            process.exit(1);
+        }
+    }
+    const task = await client.createTask(body);
+    const fmt = getFormat(opts.format);
+    output(task, fmt, (t) => `Created task ${t.id}: ${t.title}`);
+});
+taskCmd
+    .command("list")
+    .description("List tasks")
+    .option("--repo <repo>", "Filter by repository ID")
+    .option("--status <status>", "Filter by status (column name)")
+    .option("--label <label>", "Filter by label")
+    .option("--parent <id>", "Filter subtasks of a parent task")
+    .option("--format <format>", "Output format (json, text)")
+    .action(async (opts) => {
+    const client = new ApiClient();
+    const params = {};
+    if (opts.repo)
+        params.repository_id = opts.repo;
+    if (opts.status)
+        params.status = opts.status;
+    if (opts.label)
+        params.label = opts.label;
+    if (opts.parent)
+        params.parent = opts.parent;
+    const tasks = await client.listTasks(params);
+    const fmt = getFormat(opts.format);
+    output(tasks, fmt, formatTaskList);
+});
+taskCmd
+    .command("claim <id>")
+    .description("Claim an assigned task — start working on it")
+    .option("--agent-name <name>", "Agent identity")
+    .option("--format <format>", "Output format (json, text)")
+    .action(async (id, opts) => {
+    const client = new ApiClient();
+    const task = await client.claimTask(id, opts.agentName);
+    const fmt = getFormat(opts.format);
+    output(task, fmt, (t) => `Claimed task ${t.id}: ${t.title} (now in progress)`);
+});
+taskCmd
+    .command("log <id> <message>")
+    .description("Add a log entry to a task")
+    .option("--agent-name <name>", "Agent identity")
+    .action(async (id, message, opts) => {
+    const client = new ApiClient();
+    await client.addLog(id, message, opts.agentName);
+    console.log("Log entry added.");
+});
+taskCmd
+    .command("cancel <id>")
+    .description("Cancel a task")
+    .option("--agent-name <name>", "Agent identity")
+    .option("--format <format>", "Output format (json, text)")
+    .action(async (id, opts) => {
+    const client = new ApiClient();
+    const body = {};
+    if (opts.agentName)
+        body.agent_name = opts.agentName;
+    const task = await client.cancelTask(id, body);
+    const fmt = getFormat(opts.format);
+    output(task, fmt, (t) => `Cancelled task ${t.id}: ${t.title}`);
+});
+taskCmd
+    .command("review <id>")
+    .description("Move a task to In Review")
+    .option("--pr-url <url>", "Pull request URL")
+    .option("--agent-name <name>", "Agent identity")
+    .option("--format <format>", "Output format (json, text)")
+    .action(async (id, opts) => {
+    const client = new ApiClient();
+    const body = {};
+    if (opts.prUrl)
+        body.pr_url = opts.prUrl;
+    if (opts.agentName)
+        body.agent_name = opts.agentName;
+    const task = await client.reviewTask(id, body);
+    const fmt = getFormat(opts.format);
+    output(task, fmt, (t) => `Moved task ${t.id} to review: ${t.title}`);
+});
+taskCmd
+    .command("complete <id>")
+    .description("Complete a task")
+    .option("--result <result>", "Completion result summary")
+    .option("--pr-url <url>", "PR URL")
+    .option("--agent-name <name>", "Agent identity")
+    .option("--format <format>", "Output format (json, text)")
+    .action(async (id, opts) => {
+    const client = new ApiClient();
+    const body = {};
+    if (opts.result)
+        body.result = opts.result;
+    if (opts.prUrl)
+        body.pr_url = opts.prUrl;
+    if (opts.agentName)
+        body.agent_id = opts.agentName;
+    const task = await client.completeTask(id, body);
+    const fmt = getFormat(opts.format);
+    output(task, fmt, (t) => `Completed task ${t.id}: ${t.title}`);
+});
+// ─── Agent ───
+const agentCmd = program.command("agent").description("Manage agents");
+agentCmd
+    .command("list")
+    .description("List all agents")
+    .option("--format <format>", "Output format (json, text)")
+    .action(async (opts) => {
+    const client = new ApiClient();
+    const agents = await client.listAgents();
+    const fmt = getFormat(opts.format);
+    output(agents, fmt, formatAgentList);
+});
+// ─── Board ───
+const boardCmd = program.command("board").description("Manage boards");
+boardCmd
+    .command("create")
+    .description("Create a new board")
+    .requiredOption("--name <name>", "Board name")
+    .option("--description <desc>", "Board description")
+    .option("--format <format>", "Output format (json, text)")
+    .action(async (opts) => {
+    const client = new ApiClient();
+    const board = await client.createBoard({ name: opts.name, description: opts.description });
+    const fmt = getFormat(opts.format);
+    output(board, fmt, (b) => `Created board ${b.id}: ${b.name}`);
+});
+boardCmd
+    .command("list")
+    .description("List all boards")
+    .option("--format <format>", "Output format (json, text)")
+    .action(async (opts) => {
+    const client = new ApiClient();
+    const boards = await client.listBoards();
+    const fmt = getFormat(opts.format);
+    output(boards, fmt, formatBoardList);
+});
+boardCmd
+    .command("view")
+    .description("View a kanban board")
+    .option("--board <name-or-id>", "Board name or ID (uses first if omitted)")
+    .option("--format <format>", "Output format (json, text)")
+    .action(async (opts) => {
+    const client = new ApiClient();
+    let boardId;
+    if (opts.board) {
+        boardId = await resolveBoardId(client, opts.board);
+    }
+    else {
+        const boards = await client.listBoards();
+        if (boards.length === 0) {
+            console.error("No boards. Create one first: agent-kanban board create --name 'My Board'");
+            process.exit(1);
+        }
+        boardId = boards[0].id;
+    }
+    const board = await client.getBoard(boardId);
+    const fmt = getFormat(opts.format);
+    output(board, fmt, formatBoard);
+});
+async function resolveBoardId(client, nameOrId) {
+    const boards = await client.listBoards();
+    const match = boards.find((b) => b.id === nameOrId || b.name === nameOrId);
+    if (!match) {
+        console.error(`Board not found: ${nameOrId}`);
+        process.exit(1);
+    }
+    return match.id;
+}
+// ─── Repo ───
+const repoCmd = program.command("repo").description("Manage repositories");
+repoCmd
+    .command("add")
+    .description("Add a repository")
+    .requiredOption("--name <name>", "Repository name")
+    .requiredOption("--url <url>", "Clone URL")
+    .option("--format <format>", "Output format (json, text)")
+    .action(async (opts) => {
+    const client = new ApiClient();
+    const repo = await client.createRepository({ name: opts.name, url: opts.url });
+    const fmt = getFormat(opts.format);
+    output(repo, fmt, (r) => `Added repository ${r.id}: ${r.name}`);
+});
+repoCmd
+    .command("list")
+    .description("List repositories")
+    .option("--format <format>", "Output format (json, text)")
+    .action(async (opts) => {
+    const client = new ApiClient();
+    const repos = await client.listRepositories();
+    const fmt = getFormat(opts.format);
+    output(repos, fmt, formatRepositoryList);
+});
+// ─── Link & Start ───
+registerLinkCommand(program);
+registerStartCommand(program);
+program.parseAsync();

package/dist/links.d.ts

@@ -0,0 +1,7 @@
+interface Links {
+    [repositoryId: string]: string;
+}
+export declare function setLink(repositoryId: string, localPath: string): void;
+export declare function getLinks(): Links;
+export declare function findPathForRepository(repositoryId: string): string | undefined;
+export {};

package/dist/links.js

@@ -0,0 +1,28 @@
+import { readFileSync, writeFileSync, mkdirSync } from "fs";
+import { join } from "path";
+import { homedir } from "os";
+const CONFIG_DIR = join(homedir(), ".agent-kanban");
+const LINKS_FILE = join(CONFIG_DIR, "links.json");
+function readLinks() {
+    try {
+        return JSON.parse(readFileSync(LINKS_FILE, "utf-8"));
+    }
+    catch {
+        return {};
+    }
+}
+function writeLinks(links) {
+    mkdirSync(CONFIG_DIR, { recursive: true });
+    writeFileSync(LINKS_FILE, JSON.stringify(links, null, 2) + "\n");
+}
+export function setLink(repositoryId, localPath) {
+    const links = readLinks();
+    links[repositoryId] = localPath;
+    writeLinks(links);
+}
+export function getLinks() {
+    return readLinks();
+}
+export function findPathForRepository(repositoryId) {
+    return readLinks()[repositoryId];
+}

package/dist/output.d.ts

@@ -0,0 +1,7 @@
+export declare function getFormat(explicit?: string): "json" | "text";
+export declare function output(data: unknown, format: "json" | "text", textFormatter?: (data: any) => string): void;
+export declare function formatTaskList(tasks: any[]): string;
+export declare function formatAgentList(agents: any[]): string;
+export declare function formatBoardList(boards: any[]): string;
+export declare function formatRepositoryList(repos: any[]): string;
+export declare function formatBoard(board: any): string;

package/dist/output.js

@@ -0,0 +1,88 @@
+const isTTY = process.stdout.isTTY;
+export function getFormat(explicit) {
+    if (explicit === "json")
+        return "json";
+    if (explicit === "text")
+        return "text";
+    return isTTY ? "text" : "json";
+}
+export function output(data, format, textFormatter) {
+    if (format === "json") {
+        console.log(JSON.stringify(data, null, 2));
+    }
+    else if (textFormatter) {
+        console.log(textFormatter(data));
+    }
+    else {
+        console.log(JSON.stringify(data, null, 2));
+    }
+}
+export function formatTaskList(tasks) {
+    if (tasks.length === 0)
+        return "No tasks found.";
+    const lines = tasks.map((t) => {
+        const priority = t.priority ? `[${t.priority}]` : "";
+        const repo = t.repository_name ? `(${t.repository_name})` : "";
+        const agent = t.assigned_to ? `→ ${t.assigned_to}` : "";
+        return `  ${t.id}  ${priority.padEnd(8)} ${t.title} ${repo} ${agent}`;
+    });
+    return lines.join("\n");
+}
+export function formatAgentList(agents) {
+    if (agents.length === 0)
+        return "No agents found.";
+    const lines = agents.map((a) => {
+        const status = `[${a.status}]`.padEnd(10);
+        const tasks = `${a.task_count} tasks`;
+        const lastActive = a.last_active_at ? `last: ${a.last_active_at}` : "never active";
+        return `  ${a.id}  ${status} ${a.name} — ${tasks}, ${lastActive}`;
+    });
+    return lines.join("\n");
+}
+export function formatBoardList(boards) {
+    if (boards.length === 0)
+        return "No boards found.";
+    const lines = boards.map((b) => {
+        const desc = b.description ? ` — ${b.description}` : "";
+        return `  ${b.id}  ${b.name}${desc}`;
+    });
+    return lines.join("\n");
+}
+export function formatRepositoryList(repos) {
+    if (repos.length === 0)
+        return "No repositories found.";
+    const lines = repos.map((r) => {
+        return `  ${r.id}  ${r.name}  ${r.url}`;
+    });
+    return lines.join("\n");
+}
+export function formatBoard(board) {
+    const cols = board.columns || [];
+    const maxWidth = 30;
+    const header = cols.map((c) => `│ ${(c.name + ` (${c.tasks.length})`).padEnd(maxWidth)} `).join("") + "│";
+    const sep = cols.map(() => "├" + "─".repeat(maxWidth + 2)).join("") + "┤";
+    const topSep = cols.map(() => "┌" + "─".repeat(maxWidth + 2)).join("") + "┐";
+    const botSep = cols.map(() => "└" + "─".repeat(maxWidth + 2)).join("") + "┘";
+    const maxRows = Math.max(...cols.map((c) => c.tasks.length), 0);
+    const rows = [];
+    for (let i = 0; i < maxRows; i++) {
+        const row = cols.map((c) => {
+            const task = c.tasks[i];
+            if (!task)
+                return `│ ${"".padEnd(maxWidth)} `;
+            const title = task.title.length > maxWidth - 2
+                ? task.title.slice(0, maxWidth - 5) + "..."
+                : task.title;
+            return `│ ${title.padEnd(maxWidth)} `;
+        }).join("") + "│";
+        rows.push(row);
+    }
+    return [
+        `Board: ${board.name}`,
+        topSep,
+        header,
+        sep,
+        ...rows,
+        botSep,
+    ].join("\n");
+}

package/dist/processManager.d.ts

@@ -0,0 +1,24 @@
+import { type ChildProcess } from "child_process";
+import type { ApiClient, AgentClient } from "./client.js";
+export interface AgentProcess {
+    taskId: string;
+    sessionId: string;
+    process: ChildProcess;
+    agentClient?: AgentClient;
+    timeoutTimer?: ReturnType<typeof setTimeout>;
+}
+export declare class ProcessManager {
+    private agents;
+    private client;
+    private agentCli;
+    private onSlotFreed;
+    private taskTimeoutMs;
+    constructor(client: ApiClient, agentCli: string, onSlotFreed: () => void, taskTimeoutMs?: number);
+    get activeCount(): number;
+    hasTask(taskId: string): boolean;
+    spawnAgent(taskId: string, sessionId: string, cwd: string, taskContext: string, agentClient?: AgentClient): Promise<void>;
+    killAll(): Promise<void>;
+    private handleEvent;
+    private postMessage;
+    private releaseTask;
+}

package/dist/processManager.js

@@ -0,0 +1,189 @@
+import { spawn } from "child_process";
+export class ProcessManager {
+    agents = new Map();
+    client;
+    agentCli;
+    onSlotFreed;
+    taskTimeoutMs;
+    constructor(client, agentCli, onSlotFreed, taskTimeoutMs = 2 * 60 * 60 * 1000) {
+        this.client = client;
+        this.agentCli = agentCli;
+        this.onSlotFreed = onSlotFreed;
+        this.taskTimeoutMs = taskTimeoutMs;
+    }
+    get activeCount() {
+        return this.agents.size;
+    }
+    hasTask(taskId) {
+        return this.agents.has(taskId);
+    }
+    async spawnAgent(taskId, sessionId, cwd, taskContext, agentClient) {
+        const args = [
+            "--print",
+            "--verbose",
+            "--input-format", "stream-json",
+            "--output-format", "stream-json",
+            "--dangerously-skip-permissions",
+            "--session-id", sessionId,
+            "-w",
+        ];
+        let proc;
+        try {
+            proc = spawn(this.agentCli, args, {
+                cwd,
+                stdio: ["pipe", "pipe", "pipe"],
+                env: { ...process.env },
+            });
+        }
+        catch (err) {
+            console.error(`[ERROR] Failed to spawn ${this.agentCli}: ${err.message}`);
+            await this.releaseTask(taskId);
+            return;
+        }
+        if (!proc.pid) {
+            console.error(`[ERROR] ${this.agentCli} not found or failed to start`);
+            await this.releaseTask(taskId);
+            return;
+        }
+        const agent = { taskId, sessionId, process: proc, agentClient };
+        this.agents.set(taskId, agent);
+        // Kill agent if it exceeds the task timeout
+        if (this.taskTimeoutMs > 0) {
+            agent.timeoutTimer = setTimeout(() => {
+                console.warn(`[WARN] Agent for task ${taskId} exceeded timeout (${Math.round(this.taskTimeoutMs / 60000)}m), killing`);
+                proc.kill("SIGTERM");
+            }, this.taskTimeoutMs);
+        }
+        // Send task context as JSON message via stdin, then close
+        proc.on("spawn", () => {
+            const payload = JSON.stringify({
+                type: "user",
+                message: { role: "user", content: taskContext },
+            });
+            proc.stdin?.write(payload + "\n");
+            proc.stdin?.end();
+        });
+        // Parse stdout (stream-json): each line is a JSON event
+        let stdoutBuffer = "";
+        proc.stdout?.on("data", (chunk) => {
+            stdoutBuffer += chunk.toString();
+            const lines = stdoutBuffer.split("\n");
+            stdoutBuffer = lines.pop() || "";
+            for (const line of lines) {
+                if (!line.trim())
+                    continue;
+                try {
+                    const event = JSON.parse(line);
+                    this.handleEvent(taskId, sessionId, event, agentClient);
+                }
+                catch { /* non-JSON line, skip */ }
+            }
+        });
+        // Capture stderr for crash diagnostics
+        let stderrBuffer = "";
+        proc.stderr?.on("data", (chunk) => {
+            stderrBuffer += chunk.toString();
+            if (stderrBuffer.length > 10000)
+                stderrBuffer = stderrBuffer.slice(-5000);
+        });
+        // Handle exit
+        proc.on("close", async (code) => {
+            // Clear timeout timer
+            if (agent.timeoutTimer)
+                clearTimeout(agent.timeoutTimer);
+            // Flush remaining stdout
+            if (stdoutBuffer.trim()) {
+                try {
+                    const event = JSON.parse(stdoutBuffer);
+                    this.handleEvent(taskId, sessionId, event, agentClient);
+                }
+                catch { /* skip */ }
+            }
+            this.agents.delete(taskId);
+            if (code === 0) {
+                console.log(`[INFO] Agent finished task ${taskId}`);
+            }
+            else {
+                console.warn(`[WARN] Agent crashed on task ${taskId} (exit ${code})`);
+                if (stderrBuffer.trim()) {
+                    const lastLines = stderrBuffer.trim().split("\n").slice(-5).join("\n");
+                    console.warn(`  stderr: ${lastLines}`);
+                }
+                await this.releaseTask(taskId);
+            }
+            this.onSlotFreed();
+        });
+        proc.on("error", async (err) => {
+            console.error(`[ERROR] Agent process error for task ${taskId}: ${err.message}`);
+            if (agent.timeoutTimer)
+                clearTimeout(agent.timeoutTimer);
+            this.agents.delete(taskId);
+            await this.releaseTask(taskId);
+            this.onSlotFreed();
+        });
+        console.log(`[INFO] Spawned ${this.agentCli} (session=${sessionId}) for task ${taskId} in ${cwd}`);
+    }
+    async killAll() {
+        const entries = [...this.agents.entries()];
+        for (const [taskId, agent] of entries) {
+            console.log(`[INFO] Killing agent for task ${taskId}`);
+            if (agent.timeoutTimer)
+                clearTimeout(agent.timeoutTimer);
+            agent.process.kill("SIGTERM");
+            this.agents.delete(taskId);
+            await this.releaseTask(taskId);
+        }
+    }
+    handleEvent(taskId, sessionId, event, agentClient) {
+        // Extract text from assistant messages → post as agent chat messages
+        if (event.type === "assistant" && Array.isArray(event.message?.content)) {
+            for (const block of event.message.content) {
+                if (block.type === "text" && block.text) {
+                    this.postMessage(taskId, sessionId, "agent", block.text, agentClient).catch(() => { });
+                }
+            }
+        }
+        // Report usage on result event
+        if (event.type === "result") {
+            const cost = event.total_cost_usd || 0;
+            const usage = event.usage || {};
+            console.log(`[INFO] Agent result for task ${taskId}: cost=$${cost.toFixed(4)}`);
+            const usageData = {
+                input_tokens: usage.input_tokens || 0,
+                output_tokens: usage.output_tokens || 0,
+                cache_read_tokens: usage.cache_read_input_tokens || 0,
+                cache_creation_tokens: usage.cache_creation_input_tokens || 0,
+                cost_micro_usd: Math.round(cost * 1_000_000),
+            };
+            if (agentClient) {
+                agentClient.updateAgentUsage(usageData).catch(() => { });
+            }
+            else {
+                this.client.updateAgentUsage(sessionId, usageData).catch(() => { });
+            }
+        }
+    }
+    async postMessage(taskId, sessionId, role, content, agentClient) {
+        const body = { agent_id: sessionId, role, content };
+        if (agentClient) {
+            await agentClient.sendMessage(taskId, body);
+        }
+        else {
+            await this.client.sendMessage(taskId, body);
+        }
+    }
+    async releaseTask(taskId, retries = 3) {
+        for (let i = 0; i < retries; i++) {
+            try {
+                await this.client.releaseTask(taskId);
+                return;
+            }
+            catch (err) {
+                console.error(`[WARN] Failed to release task ${taskId} (attempt ${i + 1}/${retries}): ${err.message}`);
+                if (i < retries - 1)
+                    await new Promise((r) => setTimeout(r, 1000 * (i + 1)));
+            }
+        }
+        console.error(`[ERROR] Could not release task ${taskId} after ${retries} attempts. Task will remain locked until stale detection.`);
+    }
+}

package/dist/project.d.ts

@@ -0,0 +1,11 @@
+import type { ApiClient } from "./client.js";
+/**
+ * Detect project name from context.
+ * Precedence: explicit flag > .agent-kanban.json > git repo basename > undefined
+ */
+export declare function detectProjectName(explicit?: string): string | undefined;
+/**
+ * Resolve project name to project_id via API.
+ * Returns id if found, undefined if no project name detected.
+ */
+export declare function detectProjectId(client: ApiClient, explicit?: string): Promise<string | undefined>;

package/dist/project.js

@@ -0,0 +1,44 @@
+import { existsSync, readFileSync } from "fs";
+import { execSync } from "child_process";
+import { join, basename, dirname } from "path";
+/**
+ * Detect project name from context.
+ * Precedence: explicit flag > .agent-kanban.json > git repo basename > undefined
+ */
+export function detectProjectName(explicit) {
+    if (explicit)
+        return explicit;
+    // Walk up from cwd looking for .agent-kanban.json
+    let dir = process.cwd();
+    while (dir !== dirname(dir)) {
+        const configPath = join(dir, ".agent-kanban.json");
+        if (existsSync(configPath)) {
+            try {
+                const config = JSON.parse(readFileSync(configPath, "utf-8"));
+                if (config.project)
+                    return config.project;
+            }
+            catch { /* ignore malformed */ }
+        }
+        dir = dirname(dir);
+    }
+    // Try git repo basename
+    try {
+        const root = execSync("git rev-parse --show-toplevel", { encoding: "utf-8" }).trim();
+        return basename(root);
+    }
+    catch { /* not a git repo */ }
+    return undefined;
+}
+/**
+ * Resolve project name to project_id via API.
+ * Returns id if found, undefined if no project name detected.
+ */
+export async function detectProjectId(client, explicit) {
+    const name = detectProjectName(explicit);
+    if (!name)
+        return undefined;
+    const projects = await client.listProjects();
+    const match = projects.find((p) => p.name === name);
+    return match?.id;
+}