@corners/cli 0.0.1

package/dist/cli.js

@@ -0,0 +1,1284 @@
+import { readFile } from "node:fs/promises";
+import { hostname } from "node:os";
+import { basename } from "node:path";
+import { parseArgs } from "node:util";
+import { CornersApiClient as DefaultCornersApiClient, } from "./client.js";
+import { ConfigStore } from "./config.js";
+import { CLIError, getPackageVersion, openUrlInBrowser, printJson, printLine, readTextFromStdin, sleep, toGraphQLAttachmentKind, toGraphQLWorkstreamUpdateType, toIsoString, } from "./support.js";
+const LIST_WORKSTREAMS_QUERY = `
+  query CliListWorkstreams {
+    workstreams(filter: { status: ACTIVE }, first: 100) {
+      edges {
+        node {
+          id
+          cornerId
+          name
+          summary
+          category
+          status
+          updatedAt
+          topic {
+            id
+            name
+          }
+        }
+      }
+    }
+  }
+`;
+const WORKSTREAM_LOOKUP_QUERY = `
+  query CliWorkstreamLookup($id: ID!) {
+    workstream(id: $id) {
+      id
+      accountId
+      cornerId
+      name
+      summary
+      category
+      status
+      updatedAt
+      topic {
+        id
+        name
+      }
+    }
+  }
+`;
+const WORKSTREAM_PULL_QUERY = `
+  query CliWorkstreamPull($id: ID!, $attachmentsFirst: Int!, $feedFirst: Int!) {
+    workstream(id: $id) {
+      id
+      accountId
+      cornerId
+      name
+      summary
+      category
+      status
+      createdAt
+      updatedAt
+      firstAttachmentActivityAt
+      lastAttachmentActivityAt
+      topic {
+        id
+        name
+        summary
+      }
+      topicPath {
+        topicId
+        name
+      }
+      openQuestions: questions(status: OPEN) {
+        id
+        workstreamId
+        status
+        question
+        rationale
+        askOf {
+          actorId
+          externalId
+          userId
+        }
+        evidenceRefs
+        suggestedAnswers
+        answerText
+        answeredAt
+        answeredByUserId
+        createdAt
+        updatedAt
+      }
+      answeredQuestions: questions(status: ANSWERED) {
+        id
+        workstreamId
+        status
+        question
+        rationale
+        askOf {
+          actorId
+          externalId
+          userId
+        }
+        evidenceRefs
+        suggestedAnswers
+        answerText
+        answeredAt
+        answeredByUserId
+        createdAt
+        updatedAt
+      }
+      attachments(first: $attachmentsFirst) {
+        totalCount
+        edges {
+          node {
+            __typename
+            attachmentId
+            entityId
+            kind
+            title
+            summary
+            metadata
+            createdAt
+            updatedAt
+            lastActivityAt
+            ... on ArtifactThread {
+              id
+              providerType
+              visibility
+              topic
+              lastMessageAt
+              messages {
+                id
+                senderRef
+                content
+                contentType
+                sentAt
+                editedAt
+                deletedAt
+              }
+            }
+            ... on WorkstreamDocumentAttachment {
+              document {
+                id
+                title
+                content
+                updatedAt
+              }
+            }
+          }
+        }
+      }
+      feed(first: $feedFirst) {
+        totalCount
+        edges {
+          node {
+            id
+            eventType
+            sourceEntityType
+            sourceEntityId
+            payload
+            createdAt
+          }
+        }
+      }
+    }
+  }
+`;
+const WORKSTREAM_QUESTION_LIST_QUERY = `
+  query CliWorkstreamQuestions($id: ID!) {
+    workstream(id: $id) {
+      id
+      name
+      openQuestions: questions(status: OPEN) {
+        id
+        status
+        question
+        rationale
+        askOf {
+          actorId
+          externalId
+          userId
+        }
+        suggestedAnswers
+        answerText
+        answeredAt
+        answeredByUserId
+        createdAt
+        updatedAt
+      }
+      answeredQuestions: questions(status: ANSWERED) {
+        id
+        status
+        question
+        rationale
+        askOf {
+          actorId
+          externalId
+          userId
+        }
+        suggestedAnswers
+        answerText
+        answeredAt
+        answeredByUserId
+        createdAt
+        updatedAt
+      }
+      supersededQuestions: questions(status: SUPERSEDED) {
+        id
+        status
+        question
+        rationale
+        askOf {
+          actorId
+          externalId
+          userId
+        }
+        suggestedAnswers
+        answerText
+        answeredAt
+        answeredByUserId
+        createdAt
+        updatedAt
+      }
+    }
+  }
+`;
+const CREATE_WORKSTREAM_QUESTION_MUTATION = `
+  mutation CliCreateWorkstreamQuestion($input: CreateWorkstreamQuestionInput!) {
+    createWorkstreamQuestion(input: $input) {
+      id
+      workstreamId
+      status
+      question
+      rationale
+      askOf {
+        actorId
+        externalId
+        userId
+      }
+      suggestedAnswers
+      createdAt
+      updatedAt
+    }
+  }
+`;
+const ANSWER_WORKSTREAM_QUESTION_MUTATION = `
+  mutation CliAnswerWorkstreamQuestion($questionId: ID!, $answerText: String!) {
+    answerWorkstreamQuestion(questionId: $questionId, answerText: $answerText) {
+      id
+      workstreamId
+      status
+      question
+      answerText
+      answeredAt
+      answeredByUserId
+      updatedAt
+    }
+  }
+`;
+const ADD_WORKSTREAM_ATTACHMENT_MUTATION = `
+  mutation CliAddWorkstreamAttachment(
+    $workstreamId: ID!
+    $kind: WorkstreamAttachmentKind!
+    $entityId: ID!
+  ) {
+    addWorkstreamAttachment(
+      workstreamId: $workstreamId
+      kind: $kind
+      entityId: $entityId
+    ) {
+      id
+      cornerId
+      updatedAt
+    }
+  }
+`;
+const REPLY_ARTIFACT_THREAD_MUTATION = `
+  mutation CliReplyArtifactThread($id: ID!, $input: ReplyArtifactThreadInput!) {
+    replyArtifactThread(id: $id, input: $input) {
+      ok
+      providerType
+      threadContainerId
+      channelContainerId
+      dispatchedExternalId
+    }
+  }
+`;
+const CREATE_DOCUMENT_MUTATION = `
+  mutation CliCreateDocument($input: CreateDocumentInput!) {
+    createDocument(input: $input) {
+      id
+      title
+      updatedAt
+    }
+  }
+`;
+const RECORD_WORKSTREAM_UPDATE_MUTATION = `
+  mutation CliRecordWorkstreamUpdate($input: RecordWorkstreamUpdateInput!) {
+    recordWorkstreamUpdate(input: $input) {
+      id
+      eventType
+      sourceEntityType
+      sourceEntityId
+      payload
+      createdAt
+    }
+  }
+`;
+const REVOKE_MCP_SESSION_MUTATION = `
+  mutation CliRevokeMcpSession($id: ID!) {
+    revokeMCPSession(id: $id)
+  }
+`;
+function createRuntime() {
+    return {
+        config: new ConfigStore(),
+        stdout: process.stdout,
+        stderr: process.stderr,
+        stdin: process.stdin,
+        cwd: process.cwd(),
+        openUrl: openUrlInBrowser,
+        createClient: (input) => new DefaultCornersApiClient(input),
+        getVersion: getPackageVersion,
+    };
+}
+function printMainHelp(runtime) {
+    printLine(runtime.stdout, [
+        "corners",
+        "",
+        "Usage:",
+        "  corners [--profile <name>] [--api-url <url>] <command> [options]",
+        "",
+        "Commands:",
+        "  auth login|logout|status",
+        "  workstream (ws) list|use|current|pull|push|question|attach|reply-thread",
+        "  help",
+        "  version",
+        "",
+        "Global options:",
+        "  --help, -h",
+        "  --version, -v",
+        "  --json",
+        "  --profile <name>",
+        "  --api-url <url>",
+        "  --no-browser",
+    ].join("\n"));
+}
+function printAuthHelp(runtime) {
+    printLine(runtime.stdout, [
+        "corners auth",
+        "",
+        "Usage:",
+        "  corners auth login [--profile <name>] [--api-url <url>] [--no-browser]",
+        "  corners auth logout [--profile <name>] [--json]",
+        "  corners auth status [--profile <name>] [--json]",
+    ].join("\n"));
+}
+function printWorkstreamHelp(runtime) {
+    printLine(runtime.stdout, [
+        "corners workstream",
+        "",
+        "Usage:",
+        "  corners workstream list [--json]",
+        "  corners workstream use <workstreamId> [--json]",
+        "  corners workstream current [--json]",
+        "  corners workstream pull [workstreamId] [--json]",
+        "  corners workstream push [workstreamId] [--type <type>] [--message <text>] [--summary <text>] [--file <path>] [--title <title>] [--json]",
+        "  corners workstream question list [workstreamId] [--json]",
+        "  corners workstream question ask [workstreamId] [--question <text>] [--rationale <text>] [--suggested-answer <text>]... [--json]",
+        "  corners workstream question answer <questionId> [--text <text>] [--json]",
+        "  corners workstream attach [workstreamId] --kind <kind> --entity-id <id> [--json]",
+        "  corners workstream reply-thread <threadId> [--text <text>] [--json]",
+        "",
+        "Update types:",
+        "  status | blocker | learning | outcome",
+    ].join("\n"));
+}
+function parseLeadingCommonOptions(args) {
+    const common = {
+        json: false,
+        noBrowser: false,
+    };
+    let help = false;
+    let version = false;
+    let index = 0;
+    while (index < args.length) {
+        const value = args[index];
+        if (!value?.startsWith("-")) {
+            break;
+        }
+        switch (value) {
+            case "--json":
+                common.json = true;
+                index += 1;
+                break;
+            case "--no-browser":
+                common.noBrowser = true;
+                index += 1;
+                break;
+            case "--api-url":
+                if (!args[index + 1]) {
+                    throw new CLIError("Missing value for --api-url");
+                }
+                common.apiUrl = args[index + 1];
+                index += 2;
+                break;
+            case "--profile":
+                if (!args[index + 1]) {
+                    throw new CLIError("Missing value for --profile");
+                }
+                common.profile = args[index + 1];
+                index += 2;
+                break;
+            case "--help":
+            case "-h":
+                help = true;
+                index += 1;
+                break;
+            case "--version":
+            case "-v":
+                version = true;
+                index += 1;
+                break;
+            default:
+                return {
+                    common,
+                    rest: args.slice(index),
+                    help,
+                    version,
+                };
+        }
+    }
+    return {
+        common,
+        rest: args.slice(index),
+        help,
+        version,
+    };
+}
+function mergeCommonOptions(base, values) {
+    return {
+        json: values.json ?? base.json,
+        apiUrl: values.apiUrl ?? base.apiUrl,
+        profile: values.profile ?? base.profile,
+        noBrowser: values.noBrowser ?? base.noBrowser,
+    };
+}
+async function requireStoredProfile(runtime, common) {
+    const selected = await runtime.config.getProfile(common.profile ?? null);
+    if (!selected) {
+        throw new CLIError("Not logged in. Run `corners auth login` first.", {
+            json: common.json,
+        });
+    }
+    const profile = {
+        ...selected.profile,
+        apiUrl: common.apiUrl ?? selected.profile.apiUrl,
+    };
+    return {
+        profileName: selected.name,
+        profile,
+        client: runtime.createClient({
+            apiUrl: profile.apiUrl,
+            accessToken: profile.accessToken,
+        }),
+    };
+}
+async function pollForDeviceToken(input) {
+    const deadline = Date.now() + input.device.expires_in * 1000;
+    let intervalMs = input.device.interval * 1000;
+    while (Date.now() < deadline) {
+        const result = await input.client.exchangeDeviceCode(input.device.device_code, input.clientId);
+        if (result.access_token) {
+            return result;
+        }
+        switch (result.error) {
+            case "authorization_pending":
+                await sleep(intervalMs);
+                continue;
+            case "slow_down":
+                intervalMs += 5000;
+                await sleep(intervalMs);
+                continue;
+            case "access_denied":
+                throw new CLIError(result.error_description || "Authorization denied");
+            case "expired_token":
+                throw new CLIError(result.error_description || "Device code expired");
+            default:
+                throw new CLIError(result.error_description || "Failed to exchange device code");
+        }
+    }
+    printLine(input.stderr, "Device code expired before authorization completed.");
+    throw new CLIError("Device code expired");
+}
+async function resolveExplicitOrBoundWorkstream(runtime, common, client, profileName, explicitWorkstreamId) {
+    const workstreamId = explicitWorkstreamId ||
+        (await resolveBoundWorkstreamId(runtime, profileName));
+    const data = await client.graphql(WORKSTREAM_LOOKUP_QUERY, { id: workstreamId });
+    if (!data.workstream) {
+        throw new CLIError("Workstream not found", { json: common.json });
+    }
+    return data.workstream;
+}
+async function resolveBoundWorkstreamId(runtime, profileName) {
+    const binding = await runtime.config.getBinding(runtime.cwd);
+    if (!binding) {
+        throw new CLIError("This directory is not bound to a workstream. Run `corners workstream use <workstreamId>` first.");
+    }
+    if (binding.profile && binding.profile !== profileName) {
+        throw new CLIError(`This directory is bound to profile ${binding.profile}. Switch profiles or rebind the directory.`);
+    }
+    return binding.workstreamId;
+}
+function maybeTakeWorkstreamId(positionals) {
+    if (positionals[0]?.startsWith("ws_")) {
+        return {
+            workstreamId: positionals[0],
+            rest: positionals.slice(1),
+        };
+    }
+    return {
+        rest: positionals,
+    };
+}
+async function handleAuth(args, runtime, inherited) {
+    const subcommand = args[0];
+    if (!subcommand || subcommand === "help" || subcommand === "--help") {
+        printAuthHelp(runtime);
+        return 0;
+    }
+    switch (subcommand) {
+        case "login": {
+            const parsed = parseArgs({
+                args: args.slice(1),
+                allowPositionals: false,
+                options: {
+                    json: { type: "boolean" },
+                    help: { type: "boolean", short: "h" },
+                    profile: { type: "string" },
+                    "api-url": { type: "string" },
+                    "no-browser": { type: "boolean" },
+                },
+            });
+            const common = mergeCommonOptions(inherited, {
+                json: parsed.values.json,
+                profile: parsed.values.profile,
+                apiUrl: parsed.values["api-url"],
+                noBrowser: parsed.values["no-browser"],
+            });
+            if (parsed.values.help) {
+                printAuthHelp(runtime);
+                return 0;
+            }
+            const existing = await runtime.config.getProfile(common.profile ?? null);
+            const profileName = common.profile ?? existing?.name ?? "default";
+            const clientId = `Corners CLI (${hostname()})`;
+            const client = runtime.createClient({
+                apiUrl: common.apiUrl ?? existing?.profile.apiUrl,
+            });
+            if (!common.json) {
+                printLine(runtime.stderr, `Requesting device authorization from ${client.apiUrl}...`);
+            }
+            const device = await client.createDeviceAuthorization(clientId);
+            if (!common.json) {
+                printLine(runtime.stderr, `Approve this login at ${device.verification_uri} with code ${device.user_code}`);
+            }
+            if (!common.noBrowser) {
+                const opened = await runtime.openUrl(device.verification_uri_complete);
+                if (!common.json && opened) {
+                    printLine(runtime.stderr, "Opened the verification page in your browser.");
+                }
+            }
+            if (!common.json) {
+                printLine(runtime.stderr, "Waiting for device approval...");
+            }
+            const token = await pollForDeviceToken({
+                client,
+                device,
+                clientId,
+                stderr: runtime.stderr,
+            });
+            if (!token.access_token) {
+                throw new CLIError("Login completed without an access token");
+            }
+            const profile = {
+                apiUrl: client.apiUrl,
+                accessToken: token.access_token,
+                sessionId: token.session_id ?? null,
+                workspace: token.workspace ?? null,
+                accountId: token.account_id ?? null,
+                userId: token.user_id ?? null,
+                createdAt: toIsoString(),
+            };
+            await runtime.config.saveProfile(profileName, profile, {
+                setActive: true,
+            });
+            if (common.json) {
+                printJson(runtime.stdout, {
+                    ok: true,
+                    profile: profileName,
+                    apiUrl: profile.apiUrl,
+                    sessionId: profile.sessionId,
+                    workspace: profile.workspace,
+                    accountId: profile.accountId,
+                    userId: profile.userId,
+                });
+            }
+            else {
+                printLine(runtime.stdout, `Logged in as profile ${profileName}${profile.workspace ? ` (${profile.workspace})` : ""}.`);
+            }
+            return 0;
+        }
+        case "logout": {
+            const parsed = parseArgs({
+                args: args.slice(1),
+                allowPositionals: false,
+                options: {
+                    json: { type: "boolean" },
+                    help: { type: "boolean", short: "h" },
+                    profile: { type: "string" },
+                    "api-url": { type: "string" },
+                },
+            });
+            const common = mergeCommonOptions(inherited, {
+                json: parsed.values.json,
+                profile: parsed.values.profile,
+                apiUrl: parsed.values["api-url"],
+            });
+            if (parsed.values.help) {
+                printAuthHelp(runtime);
+                return 0;
+            }
+            const selected = await runtime.config.getProfile(common.profile ?? null);
+            if (!selected) {
+                if (common.json) {
+                    printJson(runtime.stdout, {
+                        ok: true,
+                        revoked: false,
+                        loggedIn: false,
+                    });
+                }
+                else {
+                    printLine(runtime.stdout, "No stored profile is logged in.");
+                }
+                return 0;
+            }
+            let revoked = false;
+            if (selected.profile.sessionId && selected.profile.accessToken) {
+                try {
+                    const client = runtime.createClient({
+                        apiUrl: common.apiUrl ?? selected.profile.apiUrl,
+                        accessToken: selected.profile.accessToken,
+                    });
+                    const data = await client.graphql(REVOKE_MCP_SESSION_MUTATION, {
+                        id: selected.profile.sessionId,
+                    });
+                    revoked = data.revokeMCPSession;
+                }
+                catch (error) {
+                    if (!common.json) {
+                        printLine(runtime.stderr, `Warning: failed to revoke the remote session (${error.message}). Clearing local credentials anyway.`);
+                    }
+                }
+            }
+            await runtime.config.removeProfile(selected.name);
+            await runtime.config.clearBindingsForProfile(selected.name);
+            if (common.json) {
+                printJson(runtime.stdout, {
+                    ok: true,
+                    revoked,
+                    profile: selected.name,
+                });
+            }
+            else {
+                printLine(runtime.stdout, `Logged out profile ${selected.name}.`);
+            }
+            return 0;
+        }
+        case "status": {
+            const parsed = parseArgs({
+                args: args.slice(1),
+                allowPositionals: false,
+                options: {
+                    json: { type: "boolean" },
+                    help: { type: "boolean", short: "h" },
+                    profile: { type: "string" },
+                    "api-url": { type: "string" },
+                },
+            });
+            const common = mergeCommonOptions(inherited, {
+                json: parsed.values.json,
+                profile: parsed.values.profile,
+                apiUrl: parsed.values["api-url"],
+            });
+            if (parsed.values.help) {
+                printAuthHelp(runtime);
+                return 0;
+            }
+            const selected = await runtime.config.getProfile(common.profile ?? null);
+            if (!selected) {
+                const status = {
+                    loggedIn: false,
+                    profile: common.profile ?? null,
+                };
+                if (common.json) {
+                    printJson(runtime.stdout, status);
+                }
+                else {
+                    printLine(runtime.stdout, "Not logged in.");
+                }
+                return 0;
+            }
+            const client = runtime.createClient({
+                apiUrl: common.apiUrl ?? selected.profile.apiUrl,
+                accessToken: selected.profile.accessToken,
+            });
+            let remote;
+            try {
+                remote = await client.validateSession();
+            }
+            catch (error) {
+                remote = {
+                    valid: false,
+                    error: error.message,
+                };
+            }
+            const status = {
+                loggedIn: true,
+                profile: selected.name,
+                apiUrl: common.apiUrl ?? selected.profile.apiUrl,
+                sessionId: selected.profile.sessionId,
+                workspace: selected.profile.workspace,
+                accountId: selected.profile.accountId,
+                userId: selected.profile.userId,
+                remoteValid: remote.valid,
+                remoteError: remote.valid ? null : (remote.error ?? null),
+            };
+            if (common.json) {
+                printJson(runtime.stdout, status);
+            }
+            else {
+                printLine(runtime.stdout, [
+                    `Profile: ${status.profile}`,
+                    `API URL: ${status.apiUrl}`,
+                    `Workspace: ${status.workspace ?? "-"}`,
+                    `Account: ${status.accountId ?? "-"}`,
+                    `User: ${status.userId ?? "-"}`,
+                    `Session: ${status.sessionId ?? "-"}`,
+                    `Remote session: ${status.remoteValid ? "valid" : `invalid (${status.remoteError ?? "unknown error"})`}`,
+                ].join("\n"));
+            }
+            return 0;
+        }
+        default:
+            throw new CLIError(`Unknown auth command: ${subcommand}`);
+    }
+}
+async function handleWorkstream(args, runtime, inherited) {
+    const subcommand = args[0];
+    if (!subcommand || subcommand === "help" || subcommand === "--help") {
+        printWorkstreamHelp(runtime);
+        return 0;
+    }
+    switch (subcommand) {
+        case "list": {
+            const parsed = parseArgs({
+                args: args.slice(1),
+                allowPositionals: false,
+                options: {
+                    json: { type: "boolean" },
+                    help: { type: "boolean", short: "h" },
+                    profile: { type: "string" },
+                    "api-url": { type: "string" },
+                },
+            });
+            const common = mergeCommonOptions(inherited, {
+                json: parsed.values.json,
+                profile: parsed.values.profile,
+                apiUrl: parsed.values["api-url"],
+            });
+            if (parsed.values.help) {
+                printWorkstreamHelp(runtime);
+                return 0;
+            }
+            const { client } = await requireStoredProfile(runtime, common);
+            const data = await client.graphql(LIST_WORKSTREAMS_QUERY);
+            const workstreams = data.workstreams.edges.map((edge) => edge.node);
+            if (common.json) {
+                printJson(runtime.stdout, workstreams);
+            }
+            else {
+                printLine(runtime.stdout, workstreams
+                    .map((workstream) => `${workstream.id}  ${workstream.name}  ${workstream.status.toLowerCase()}${workstream.summary ? `  ${workstream.summary}` : ""}`)
+                    .join("\n"));
+            }
+            return 0;
+        }
+        case "use": {
+            const parsed = parseArgs({
+                args: args.slice(1),
+                allowPositionals: true,
+                options: {
+                    json: { type: "boolean" },
+                    help: { type: "boolean", short: "h" },
+                    profile: { type: "string" },
+                    "api-url": { type: "string" },
+                },
+            });
+            const common = mergeCommonOptions(inherited, {
+                json: parsed.values.json,
+                profile: parsed.values.profile,
+                apiUrl: parsed.values["api-url"],
+            });
+            if (parsed.values.help) {
+                printWorkstreamHelp(runtime);
+                return 0;
+            }
+            const workstreamId = parsed.positionals[0];
+            if (!workstreamId) {
+                throw new CLIError("Usage: corners workstream use <workstreamId>", {
+                    json: common.json,
+                });
+            }
+            const { profileName, profile, client } = await requireStoredProfile(runtime, common);
+            const workstream = await resolveExplicitOrBoundWorkstream(runtime, common, client, profileName, workstreamId);
+            await runtime.config.setBinding(runtime.cwd, {
+                profile: profileName,
+                workspace: profile.workspace ?? "",
+                workstreamId: workstream.id,
+                cornerId: workstream.cornerId,
+                boundAt: toIsoString(),
+            });
+            if (common.json) {
+                printJson(runtime.stdout, {
+                    ok: true,
+                    cwd: runtime.cwd,
+                    profile: profileName,
+                    workspace: profile.workspace,
+                    workstream,
+                });
+            }
+            else {
+                printLine(runtime.stdout, `Bound ${runtime.cwd} to ${workstream.id} (${workstream.name}).`);
+            }
+            return 0;
+        }
+        case "current": {
+            const parsed = parseArgs({
+                args: args.slice(1),
+                allowPositionals: false,
+                options: {
+                    json: { type: "boolean" },
+                    help: { type: "boolean", short: "h" },
+                },
+            });
+            const common = mergeCommonOptions(inherited, {
+                json: parsed.values.json,
+            });
+            if (parsed.values.help) {
+                printWorkstreamHelp(runtime);
+                return 0;
+            }
+            const binding = await runtime.config.getBinding(runtime.cwd);
+            if (!binding) {
+                if (common.json) {
+                    printJson(runtime.stdout, { cwd: runtime.cwd, binding: null });
+                }
+                else {
+                    printLine(runtime.stdout, "No workstream is bound to this directory.");
+                }
+                return 0;
+            }
+            if (common.json) {
+                printJson(runtime.stdout, {
+                    cwd: runtime.cwd,
+                    binding,
+                });
+            }
+            else {
+                printLine(runtime.stdout, [
+                    `Directory: ${runtime.cwd}`,
+                    `Profile: ${binding.profile ?? "-"}`,
+                    `Workspace: ${binding.workspace || "-"}`,
+                    `Workstream: ${binding.workstreamId}`,
+                    `Corner: ${binding.cornerId}`,
+                ].join("\n"));
+            }
+            return 0;
+        }
+        case "pull": {
+            const parsed = parseArgs({
+                args: args.slice(1),
+                allowPositionals: true,
+                options: {
+                    json: { type: "boolean" },
+                    help: { type: "boolean", short: "h" },
+                    profile: { type: "string" },
+                    "api-url": { type: "string" },
+                },
+            });
+            const common = mergeCommonOptions(inherited, {
+                json: parsed.values.json,
+                profile: parsed.values.profile,
+                apiUrl: parsed.values["api-url"],
+            });
+            if (parsed.values.help) {
+                printWorkstreamHelp(runtime);
+                return 0;
+            }
+            const { workstreamId } = maybeTakeWorkstreamId(parsed.positionals);
+            const { profileName, client } = await requireStoredProfile(runtime, common);
+            const workstream = await resolveExplicitOrBoundWorkstream(runtime, common, client, profileName, workstreamId);
+            const data = await client.graphql(WORKSTREAM_PULL_QUERY, {
+                id: workstream.id,
+                attachmentsFirst: 50,
+                feedFirst: 20,
+            });
+            if (common.json) {
+                printJson(runtime.stdout, data.workstream);
+            }
+            else {
+                const snapshot = data.workstream;
+                printLine(runtime.stdout, [
+                    `${snapshot.name} (${snapshot.id})`,
+                    snapshot.summary ? `Summary: ${snapshot.summary}` : "Summary: -",
+                    `Open questions: ${snapshot.openQuestions?.length ?? 0}`,
+                    `Answered questions: ${snapshot.answeredQuestions?.length ?? 0}`,
+                    `Attachments: ${snapshot.attachments?.totalCount ?? 0}`,
+                    `Feed items returned: ${snapshot.feed?.totalCount ?? 0}`,
+                ].join("\n"));
+            }
+            return 0;
+        }
+        case "push": {
+            const parsed = parseArgs({
+                args: args.slice(1),
+                allowPositionals: true,
+                options: {
+                    json: { type: "boolean" },
+                    help: { type: "boolean", short: "h" },
+                    profile: { type: "string" },
+                    "api-url": { type: "string" },
+                    type: { type: "string" },
+                    message: { type: "string" },
+                    summary: { type: "string" },
+                    file: { type: "string" },
+                    title: { type: "string" },
+                },
+            });
+            const common = mergeCommonOptions(inherited, {
+                json: parsed.values.json,
+                profile: parsed.values.profile,
+                apiUrl: parsed.values["api-url"],
+            });
+            if (parsed.values.help) {
+                printWorkstreamHelp(runtime);
+                return 0;
+            }
+            const { workstreamId, rest } = maybeTakeWorkstreamId(parsed.positionals);
+            const message = parsed.values.message ??
+                (rest.length > 0
+                    ? rest.join(" ")
+                    : await readTextFromStdin(runtime.stdin));
+            if (!message) {
+                throw new CLIError("Workstream updates need a message. Use --message or pipe text on stdin.", { json: common.json });
+            }
+            const { profileName, client } = await requireStoredProfile(runtime, common);
+            const workstream = await resolveExplicitOrBoundWorkstream(runtime, common, client, profileName, workstreamId);
+            let createdDocument = null;
+            if (parsed.values.file) {
+                const documentContent = await readFile(parsed.values.file, "utf8");
+                const title = parsed.values.title ?? basename(parsed.values.file);
+                const documentResult = await client.graphql(CREATE_DOCUMENT_MUTATION, {
+                    input: {
+                        title,
+                        content: documentContent,
+                        privacy: "ACCOUNT",
+                    },
+                });
+                createdDocument = documentResult.createDocument;
+            }
+            const updateResult = await client.graphql(RECORD_WORKSTREAM_UPDATE_MUTATION, {
+                input: {
+                    workstreamId: workstream.id,
+                    updateType: toGraphQLWorkstreamUpdateType(parsed.values.type ?? "status"),
+                    content: message,
+                    summary: parsed.values.summary,
+                    documentId: createdDocument?.id ?? null,
+                },
+            });
+            const payload = {
+                ok: true,
+                workstreamId: workstream.id,
+                update: updateResult.recordWorkstreamUpdate,
+                document: createdDocument,
+            };
+            if (common.json) {
+                printJson(runtime.stdout, payload);
+            }
+            else {
+                printLine(runtime.stdout, `Recorded ${String(parsed.values.type ?? "status")} update on ${workstream.id}.`);
+            }
+            return 0;
+        }
+        case "question": {
+            const nested = args[1];
+            if (!nested || nested === "help" || nested === "--help") {
+                printWorkstreamHelp(runtime);
+                return 0;
+            }
+            switch (nested) {
+                case "list": {
+                    const parsed = parseArgs({
+                        args: args.slice(2),
+                        allowPositionals: true,
+                        options: {
+                            json: { type: "boolean" },
+                            help: { type: "boolean", short: "h" },
+                            profile: { type: "string" },
+                            "api-url": { type: "string" },
+                        },
+                    });
+                    const common = mergeCommonOptions(inherited, {
+                        json: parsed.values.json,
+                        profile: parsed.values.profile,
+                        apiUrl: parsed.values["api-url"],
+                    });
+                    if (parsed.values.help) {
+                        printWorkstreamHelp(runtime);
+                        return 0;
+                    }
+                    const { workstreamId } = maybeTakeWorkstreamId(parsed.positionals);
+                    const { profileName, client } = await requireStoredProfile(runtime, common);
+                    const workstream = await resolveExplicitOrBoundWorkstream(runtime, common, client, profileName, workstreamId);
+                    const data = await client.graphql(WORKSTREAM_QUESTION_LIST_QUERY, {
+                        id: workstream.id,
+                    });
+                    if (!data.workstream) {
+                        throw new CLIError("Workstream not found", { json: common.json });
+                    }
+                    if (common.json) {
+                        printJson(runtime.stdout, data.workstream);
+                    }
+                    else {
+                        printLine(runtime.stdout, [
+                            `${data.workstream.name} (${data.workstream.id})`,
+                            `Open: ${data.workstream.openQuestions.length}`,
+                            `Answered: ${data.workstream.answeredQuestions.length}`,
+                            `Superseded: ${data.workstream.supersededQuestions.length}`,
+                        ].join("\n"));
+                    }
+                    return 0;
+                }
+                case "ask": {
+                    const parsed = parseArgs({
+                        args: args.slice(2),
+                        allowPositionals: true,
+                        options: {
+                            json: { type: "boolean" },
+                            help: { type: "boolean", short: "h" },
+                            profile: { type: "string" },
+                            "api-url": { type: "string" },
+                            question: { type: "string" },
+                            rationale: { type: "string" },
+                            "suggested-answer": { type: "string", multiple: true },
+                        },
+                    });
+                    const common = mergeCommonOptions(inherited, {
+                        json: parsed.values.json,
+                        profile: parsed.values.profile,
+                        apiUrl: parsed.values["api-url"],
+                    });
+                    if (parsed.values.help) {
+                        printWorkstreamHelp(runtime);
+                        return 0;
+                    }
+                    const { workstreamId, rest } = maybeTakeWorkstreamId(parsed.positionals);
+                    const question = parsed.values.question ??
+                        (rest.length > 0
+                            ? rest.join(" ")
+                            : await readTextFromStdin(runtime.stdin));
+                    if (!question) {
+                        throw new CLIError("Question text is required. Use --question or pipe text on stdin.", { json: common.json });
+                    }
+                    const { profileName, client } = await requireStoredProfile(runtime, common);
+                    const workstream = await resolveExplicitOrBoundWorkstream(runtime, common, client, profileName, workstreamId);
+                    const result = await client.graphql(CREATE_WORKSTREAM_QUESTION_MUTATION, {
+                        input: {
+                            workstreamId: workstream.id,
+                            question,
+                            rationale: parsed.values.rationale,
+                            suggestedAnswers: parsed.values["suggested-answer"] ?? [],
+                        },
+                    });
+                    if (common.json) {
+                        printJson(runtime.stdout, result.createWorkstreamQuestion);
+                    }
+                    else {
+                        printLine(runtime.stdout, `Created question on ${workstream.id}.`);
+                    }
+                    return 0;
+                }
+                case "answer": {
+                    const parsed = parseArgs({
+                        args: args.slice(2),
+                        allowPositionals: true,
+                        options: {
+                            json: { type: "boolean" },
+                            help: { type: "boolean", short: "h" },
+                            profile: { type: "string" },
+                            "api-url": { type: "string" },
+                            text: { type: "string" },
+                        },
+                    });
+                    const common = mergeCommonOptions(inherited, {
+                        json: parsed.values.json,
+                        profile: parsed.values.profile,
+                        apiUrl: parsed.values["api-url"],
+                    });
+                    if (parsed.values.help) {
+                        printWorkstreamHelp(runtime);
+                        return 0;
+                    }
+                    const questionId = parsed.positionals[0];
+                    const answer = parsed.values.text ??
+                        (parsed.positionals.length > 1
+                            ? parsed.positionals.slice(1).join(" ")
+                            : await readTextFromStdin(runtime.stdin));
+                    if (!questionId) {
+                        throw new CLIError("Usage: corners workstream question answer <questionId> [--text <text>]", { json: common.json });
+                    }
+                    if (!answer) {
+                        throw new CLIError("Answer text is required.", {
+                            json: common.json,
+                        });
+                    }
+                    const { client } = await requireStoredProfile(runtime, common);
+                    const result = await client.graphql(ANSWER_WORKSTREAM_QUESTION_MUTATION, {
+                        questionId,
+                        answerText: answer,
+                    });
+                    if (common.json) {
+                        printJson(runtime.stdout, result.answerWorkstreamQuestion);
+                    }
+                    else {
+                        printLine(runtime.stdout, `Answered ${questionId}.`);
+                    }
+                    return 0;
+                }
+                default:
+                    throw new CLIError(`Unknown workstream question command: ${nested}`);
+            }
+        }
+        case "attach": {
+            const parsed = parseArgs({
+                args: args.slice(1),
+                allowPositionals: true,
+                options: {
+                    json: { type: "boolean" },
+                    help: { type: "boolean", short: "h" },
+                    profile: { type: "string" },
+                    "api-url": { type: "string" },
+                    kind: { type: "string" },
+                    "entity-id": { type: "string" },
+                },
+            });
+            const common = mergeCommonOptions(inherited, {
+                json: parsed.values.json,
+                profile: parsed.values.profile,
+                apiUrl: parsed.values["api-url"],
+            });
+            if (parsed.values.help) {
+                printWorkstreamHelp(runtime);
+                return 0;
+            }
+            const { workstreamId } = maybeTakeWorkstreamId(parsed.positionals);
+            const kind = parsed.values.kind;
+            const entityId = parsed.values["entity-id"];
+            if (!kind || !entityId) {
+                throw new CLIError("Usage: corners workstream attach [workstreamId] --kind <kind> --entity-id <id>", { json: common.json });
+            }
+            const { profileName, client } = await requireStoredProfile(runtime, common);
+            const workstream = await resolveExplicitOrBoundWorkstream(runtime, common, client, profileName, workstreamId);
+            const result = await client.graphql(ADD_WORKSTREAM_ATTACHMENT_MUTATION, {
+                workstreamId: workstream.id,
+                kind: toGraphQLAttachmentKind(kind),
+                entityId,
+            });
+            if (common.json) {
+                printJson(runtime.stdout, result.addWorkstreamAttachment);
+            }
+            else {
+                printLine(runtime.stdout, `Attached ${kind}:${entityId} to ${workstream.id}.`);
+            }
+            return 0;
+        }
+        case "reply-thread": {
+            const parsed = parseArgs({
+                args: args.slice(1),
+                allowPositionals: true,
+                options: {
+                    json: { type: "boolean" },
+                    help: { type: "boolean", short: "h" },
+                    profile: { type: "string" },
+                    "api-url": { type: "string" },
+                    text: { type: "string" },
+                },
+            });
+            const common = mergeCommonOptions(inherited, {
+                json: parsed.values.json,
+                profile: parsed.values.profile,
+                apiUrl: parsed.values["api-url"],
+            });
+            if (parsed.values.help) {
+                printWorkstreamHelp(runtime);
+                return 0;
+            }
+            const threadId = parsed.positionals[0];
+            const text = parsed.values.text ??
+                (parsed.positionals.length > 1
+                    ? parsed.positionals.slice(1).join(" ")
+                    : await readTextFromStdin(runtime.stdin));
+            if (!threadId || !text) {
+                throw new CLIError("Usage: corners workstream reply-thread <threadId> [--text <text>]", { json: common.json });
+            }
+            const { client } = await requireStoredProfile(runtime, common);
+            const result = await client.graphql(REPLY_ARTIFACT_THREAD_MUTATION, {
+                id: threadId,
+                input: {
+                    text,
+                },
+            });
+            if (common.json) {
+                printJson(runtime.stdout, result.replyArtifactThread);
+            }
+            else {
+                printLine(runtime.stdout, `Replied to ${threadId}.`);
+            }
+            return 0;
+        }
+        default:
+            throw new CLIError(`Unknown workstream command: ${subcommand}`);
+    }
+}
+export async function runCli(argv, runtime = createRuntime()) {
+    const normalizedArgv = argv[0] === "--" ? argv.slice(1) : argv;
+    const parsed = parseLeadingCommonOptions(normalizedArgv);
+    if (parsed.version) {
+        printLine(runtime.stdout, runtime.getVersion());
+        return 0;
+    }
+    const command = parsed.rest[0];
+    if (!command) {
+        printMainHelp(runtime);
+        return 0;
+    }
+    if (parsed.help && !command) {
+        printMainHelp(runtime);
+        return 0;
+    }
+    switch (command) {
+        case "help":
+            if (parsed.rest[1] === "auth") {
+                printAuthHelp(runtime);
+            }
+            else if (parsed.rest[1] === "workstream" || parsed.rest[1] === "ws") {
+                printWorkstreamHelp(runtime);
+            }
+            else {
+                printMainHelp(runtime);
+            }
+            return 0;
+        case "version":
+            printLine(runtime.stdout, runtime.getVersion());
+            return 0;
+        case "auth":
+            return handleAuth(parsed.rest.slice(1), runtime, parsed.common);
+        case "workstream":
+        case "ws":
+            return handleWorkstream(parsed.rest.slice(1), runtime, parsed.common);
+        default:
+            throw new CLIError(`Unknown command: ${command}`, {
+                json: parsed.common.json,
+            });
+    }
+}
+//# sourceMappingURL=cli.js.map