linmux 0.1.0

package/dist/commands/raw/batch.js

@@ -0,0 +1,85 @@
+import { BASE_FLAGS, runCommand } from "../../lib/workspace-runtime.js";
+import { runRawBatch } from "../../lib/raw-batch-runtime.js";
+import { Command, Flags } from "@oclif/core";
+//#region src/commands/raw/batch.ts
+/**
+* `linmux raw batch --plan=@file.json` — Phase 3 PLAN 03-05, RAW-05.
+*
+* Safety-gated batch dispatcher. Defaults to --dry-run; requires --yes to execute.
+* Implementation lives in `src/lib/raw-batch-runtime.ts` (two-export pattern S1).
+*
+* This file exports BOTH:
+*   - Named `runRawBatch` re-export (for tests + future programmatic use)
+*   - Default `RawBatchCommand` oclif class
+*
+* Gate ordering (enforced in runtime):
+*   Plan validation → WSP-06 (if mutations) → --allow-mutations → dry-run/yes intent
+*
+* oclif resolves `src/commands/raw/batch.ts` → `linmux raw batch` automatically
+* via topic-tree convention.
+*/
+var RawBatchCommand = class RawBatchCommand extends Command {
+	static description = "Execute a batch of registry operations from a JSON plan file. Default dry-run; --yes required to execute.";
+	static examples = [
+		"<%= config.bin %> raw batch --plan=@./plan.json",
+		"<%= config.bin %> raw batch --plan=@./plan.json --workspace acme --allow-mutations --yes",
+		"<%= config.bin %> raw batch --plan=@./plan.json --no-dry-run --yes --workspace acme --allow-mutations"
+	];
+	static enableJsonFlag = true;
+	static flags = {
+		...BASE_FLAGS,
+		workspace: Flags.string({ description: "Workspace name override (precedence over LINEAR_WORKSPACE env / active default)" }),
+		"allow-active-workspace-write": Flags.boolean({
+			default: false,
+			description: "Permit mutations against the active workspace without an explicit --workspace selector (WSP-06 opt-in)"
+		}),
+		"allow-mutations": Flags.boolean({
+			default: false,
+			description: "Required for plans containing mutation operations — explicit safety gate"
+		}),
+		plan: Flags.string({
+			required: true,
+			description: "Plan file path as @file.json (e.g. --plan=@./plan.json)"
+		}),
+		"dry-run": Flags.boolean({
+			default: true,
+			allowNo: true,
+			description: "Print planned operations without executing (default true). Pass --no-dry-run --yes to execute."
+		}),
+		yes: Flags.boolean({
+			default: false,
+			description: "Confirm execution. Required when --no-dry-run is passed."
+		})
+	};
+	async run() {
+		const { flags } = await this.parse(RawBatchCommand);
+		const batchFlags = {
+			plan: flags.plan,
+			pretty: flags.pretty,
+			"dry-run": flags["dry-run"],
+			yes: flags.yes,
+			"allow-mutations": flags["allow-mutations"],
+			"allow-active-workspace-write": flags["allow-active-workspace-write"]
+		};
+		if (flags.workspace !== void 0) batchFlags.workspace = flags.workspace;
+		const runArgs = {
+			commandPath: "raw batch",
+			pretty: flags.pretty ?? false,
+			handler: (retryOpts) => runRawBatch({
+				flags: batchFlags,
+				env: process.env,
+				retryOptsOverride: retryOpts
+			})
+		};
+		if (flags.quiet !== void 0) runArgs.quiet = flags.quiet;
+		if (flags.noMeta !== void 0) runArgs.noMeta = flags.noMeta;
+		if (flags.retry !== void 0) runArgs.retry = flags.retry;
+		const out = await runCommand(runArgs);
+		if (!flags.json) process.stdout.write(out.stdout);
+		if (out.stderr) process.stderr.write(out.stderr);
+		if (out.exitCode !== 0) process.exitCode = out.exitCode;
+		return JSON.parse(out.stdout);
+	}
+};
+//#endregion
+export { RawBatchCommand as default, runRawBatch };

package/dist/commands/raw/index.js

@@ -0,0 +1,72 @@
+import { BASE_FLAGS, runCommand } from "../../lib/workspace-runtime.js";
+import { runRaw } from "../../lib/raw-runtime.js";
+import { Args, Command, Flags } from "@oclif/core";
+//#region src/commands/raw/index.ts
+/**
+* `linmux raw <Operation>` — Phase 3 PLAN 03-02.
+*
+* Dispatches any operation in the generated GraphQL registry.
+* Implementation lives in `src/lib/raw-runtime.ts` (two-export pattern S1 —
+* analog: `src/commands/issue/transition.ts:19-95`).
+*
+* This file exports BOTH:
+*   - Named `runRaw` re-export (for tests + future programmatic use)
+*   - Default `RawCommand` oclif class
+*
+* Gate ordering (enforced in runtime):
+*   WSP-06 (workspace selector) BEFORE --allow-mutations BEFORE dispatch.
+*/
+var RawCommand = class RawCommand extends Command {
+	static description = "Dispatch any operation in the generated GraphQL registry (501 ops).";
+	static examples = [
+		"<%= config.bin %> raw Issues --vars '{\"first\": 10}'",
+		"<%= config.bin %> raw IssueCreate --workspace acme --allow-mutations --vars '{\"input\": {\"title\": \"x\", \"teamId\": \"...\"}}'",
+		"<%= config.bin %> raw Issues --vars @vars.json"
+	];
+	static enableJsonFlag = true;
+	static args = { operation: Args.string({
+		required: true,
+		description: "PascalCase operation name (e.g. Issues, IssueCreate)"
+	}) };
+	static flags = {
+		...BASE_FLAGS,
+		workspace: Flags.string({ description: "Workspace name override (precedence over LINEAR_WORKSPACE env / active default)" }),
+		"allow-active-workspace-write": Flags.boolean({
+			default: false,
+			description: "Permit mutations against the active workspace without an explicit --workspace selector (WSP-06 opt-in)"
+		}),
+		"allow-mutations": Flags.boolean({
+			default: false,
+			description: "Required for mutation operations — explicit safety gate"
+		}),
+		vars: Flags.string({ description: "Variables as inline JSON or @file.json path (file takes precedence)" })
+	};
+	async run() {
+		const { args, flags } = await this.parse(RawCommand);
+		const rawFlags = { pretty: flags.pretty };
+		if (flags.workspace !== void 0) rawFlags.workspace = flags.workspace;
+		if (flags["allow-active-workspace-write"]) rawFlags["allow-active-workspace-write"] = flags["allow-active-workspace-write"];
+		if (flags["allow-mutations"]) rawFlags["allow-mutations"] = flags["allow-mutations"];
+		if (flags.vars !== void 0) rawFlags.vars = flags.vars;
+		const runArgs = {
+			commandPath: "raw",
+			pretty: flags.pretty ?? false,
+			handler: (retryOpts) => runRaw({
+				args,
+				flags: rawFlags,
+				env: process.env,
+				retryOptsOverride: retryOpts
+			})
+		};
+		if (flags.quiet !== void 0) runArgs.quiet = flags.quiet;
+		if (flags.noMeta !== void 0) runArgs.noMeta = flags.noMeta;
+		if (flags.retry !== void 0) runArgs.retry = flags.retry;
+		const out = await runCommand(runArgs);
+		if (!flags.json) process.stdout.write(out.stdout);
+		if (out.stderr) process.stderr.write(out.stderr);
+		if (out.exitCode !== 0) process.exitCode = out.exitCode;
+		return JSON.parse(out.stdout);
+	}
+};
+//#endregion
+export { RawCommand as default, runRaw };

package/dist/commands/schema.js

@@ -0,0 +1,69 @@
+import { BASE_FLAGS, runCommand } from "../lib/workspace-runtime.js";
+import { schemaRuntime } from "../lib/schema-runtime.js";
+import { Command, Flags } from "@oclif/core";
+//#region src/commands/schema.ts
+/**
+* `linmux schema` — Phase 4 PLAN 04-04, INT-03.
+*
+* Returns the Linear GraphQL schema without making any network calls.
+* Sources the vendored `schema.graphql` via schema-loader.ts (lazy-cached).
+*
+* Default: compact SDL (triple-quoted descriptions stripped) for token efficiency.
+* --full:  SDL with all descriptions included.
+* --json:  Standard introspection JSON (__schema format) for programmatic tooling.
+*
+* No --workspace flag — this command makes zero network calls.
+*/
+async function runSchema(args) {
+	const runArgs = {
+		commandPath: "schema",
+		pretty: args.pretty,
+		handler: async (_retryOpts) => {
+			return {
+				data: (await schemaRuntime({ flags: {
+					full: args.full,
+					json: args.json
+				} })).data,
+				meta: {}
+			};
+		}
+	};
+	if (args.noMeta !== void 0) runArgs.noMeta = args.noMeta;
+	if (args.quiet !== void 0) runArgs.quiet = args.quiet;
+	if (args.retry !== void 0) runArgs.retry = args.retry;
+	return runCommand(runArgs);
+}
+var Schema = class Schema extends Command {
+	static description = "Return the Linear GraphQL schema as compact SDL (descriptions stripped by default), or as introspection JSON with --json.";
+	static enableJsonFlag = true;
+	static flags = {
+		...BASE_FLAGS,
+		full: Flags.boolean({
+			description: "Include type descriptions in the SDL output (default: stripped for token efficiency)",
+			default: false
+		}),
+		json: Flags.boolean({
+			description: "Return introspection JSON (__schema format) instead of SDL text",
+			default: false,
+			char: "j"
+		})
+	};
+	async run() {
+		const { flags } = await this.parse(Schema);
+		const callArgs = {
+			pretty: flags.pretty,
+			full: flags.full,
+			json: flags.json
+		};
+		if (flags.quiet !== void 0) callArgs.quiet = flags.quiet;
+		if (flags.noMeta !== void 0) callArgs.noMeta = flags.noMeta;
+		if (flags.retry !== void 0) callArgs.retry = flags.retry;
+		const out = await runSchema(callArgs);
+		if (!flags.json) process.stdout.write(out.stdout);
+		if (out.stderr) process.stderr.write(out.stderr);
+		if (out.exitCode !== 0) process.exitCode = out.exitCode;
+		return JSON.parse(out.stdout);
+	}
+};
+//#endregion
+export { Schema as default, runSchema };

package/dist/commands/state/list.js

@@ -0,0 +1,77 @@
+import { BASE_FLAGS, runCommand } from "../../lib/workspace-runtime.js";
+import { PAGINATION_FLAGS } from "../../core/pagination/flags.js";
+import "../../core/pagination/index.js";
+import { stateListRuntime } from "../../lib/state-list-runtime.js";
+import { Command, Flags } from "@oclif/core";
+//#region src/commands/state/list.ts
+/**
+* `linmux state list` -- Phase 2 PLAN 02-09 Task 1, STA-01.
+*
+* Read command. Lists workflow states either across all teams the viewer can
+* see (no filter) OR scoped to one team via `--team` (UUID, key, or name).
+* Per CONTEXT § Specifics line 116, `--team` is OPTIONAL.
+*
+* Implementation lives in `src/lib/state-list-runtime.ts` per the Phase 1
+* PLAN-04 invariant. Exports BOTH the default Command class AND a named
+* `runStateList(args)` function.
+*/
+async function runStateList(args) {
+	const runArgs = {
+		commandPath: "state list",
+		pretty: args.pretty,
+		handler: async (retryOpts) => {
+			const runtimeFlags = {};
+			if (args.workspace !== void 0) runtimeFlags.workspace = args.workspace;
+			if (args.fields !== void 0) runtimeFlags.fields = args.fields;
+			if (args.limit !== void 0) runtimeFlags.limit = args.limit;
+			if (args.cursor !== void 0) runtimeFlags.cursor = args.cursor;
+			if (args.team !== void 0) runtimeFlags.team = args.team;
+			const result = await stateListRuntime({
+				flags: runtimeFlags,
+				env: process.env,
+				retryOptsOverride: retryOpts
+			});
+			return {
+				data: result.data,
+				meta: result.meta
+			};
+		}
+	};
+	if (args.noMeta !== void 0) runArgs.noMeta = args.noMeta;
+	if (args.quiet !== void 0) runArgs.quiet = args.quiet;
+	if (args.retry !== void 0) runArgs.retry = args.retry;
+	return runCommand(runArgs);
+}
+var StateList = class StateList extends Command {
+	static description = "List Linear workflow states. Pass --team <UUID|key|name> to scope to one team; otherwise lists all states the viewer can see.";
+	static enableJsonFlag = true;
+	static flags = {
+		...BASE_FLAGS,
+		...PAGINATION_FLAGS,
+		workspace: Flags.string({ description: "Workspace name (overrides active default and LINEAR_WORKSPACE)" }),
+		fields: Flags.string({
+			description: "Field preset (ids|defaults|full) or comma-separated list",
+			default: "defaults"
+		}),
+		team: Flags.string({ description: "Optional team filter (UUID, key, or name)" })
+	};
+	async run() {
+		const { flags } = await this.parse(StateList);
+		const callArgs = { pretty: flags.pretty };
+		if (flags.workspace !== void 0) callArgs.workspace = flags.workspace;
+		if (flags.fields !== void 0) callArgs.fields = flags.fields;
+		if (flags.limit !== void 0) callArgs.limit = flags.limit;
+		if (flags.cursor !== void 0) callArgs.cursor = flags.cursor;
+		if (flags.team !== void 0) callArgs.team = flags.team;
+		if (flags.quiet !== void 0) callArgs.quiet = flags.quiet;
+		if (flags.noMeta !== void 0) callArgs.noMeta = flags.noMeta;
+		if (flags.retry !== void 0) callArgs.retry = flags.retry;
+		const out = await runStateList(callArgs);
+		if (!flags.json) process.stdout.write(out.stdout);
+		if (out.stderr) process.stderr.write(out.stderr);
+		if (out.exitCode !== 0) process.exitCode = out.exitCode;
+		return JSON.parse(out.stdout);
+	}
+};
+//#endregion
+export { StateList as default, runStateList };

package/dist/commands/team/get.js

@@ -0,0 +1,73 @@
+import { BASE_FLAGS, runCommand } from "../../lib/workspace-runtime.js";
+import { teamGetRuntime } from "../../lib/team-get-runtime.js";
+import { Args, Command, Flags } from "@oclif/core";
+//#region src/commands/team/get.ts
+/**
+* `linmux team get <ref>` -- Phase 2 PLAN 02-09 Task 1, TEM-01.get.
+*
+* Single-entity read. Accepts a UUID, team key (e.g. `ENG`), or team name.
+* Implementation lives in `src/lib/team-get-runtime.ts`.
+*
+* Exports BOTH the default Command class AND a named `runTeamGet(args)`
+* function.
+*/
+async function runTeamGet(args) {
+	const runArgs = {
+		commandPath: "team get",
+		pretty: args.pretty,
+		handler: async (retryOpts) => {
+			const runtimeFlags = {};
+			if (args.workspace !== void 0) runtimeFlags.workspace = args.workspace;
+			if (args.fields !== void 0) runtimeFlags.fields = args.fields;
+			const result = await teamGetRuntime({
+				args: { ref: args.ref },
+				flags: runtimeFlags,
+				env: process.env,
+				retryOptsOverride: retryOpts
+			});
+			return {
+				data: result.data,
+				meta: result.meta
+			};
+		}
+	};
+	if (args.noMeta !== void 0) runArgs.noMeta = args.noMeta;
+	if (args.quiet !== void 0) runArgs.quiet = args.quiet;
+	if (args.retry !== void 0) runArgs.retry = args.retry;
+	return runCommand(runArgs);
+}
+var TeamGet = class TeamGet extends Command {
+	static description = "Get a single Linear team by UUID, key (e.g. ENG), or name.";
+	static enableJsonFlag = true;
+	static args = { ref: Args.string({
+		required: true,
+		description: "Team UUID, key (e.g. ENG), or name"
+	}) };
+	static flags = {
+		...BASE_FLAGS,
+		workspace: Flags.string({ description: "Workspace name (overrides active default and LINEAR_WORKSPACE)" }),
+		fields: Flags.string({
+			description: "Field preset (ids|defaults|full) or comma-separated list",
+			default: "defaults"
+		})
+	};
+	async run() {
+		const { args, flags } = await this.parse(TeamGet);
+		const callArgs = {
+			ref: args.ref,
+			pretty: flags.pretty
+		};
+		if (flags.workspace !== void 0) callArgs.workspace = flags.workspace;
+		if (flags.fields !== void 0) callArgs.fields = flags.fields;
+		if (flags.quiet !== void 0) callArgs.quiet = flags.quiet;
+		if (flags.noMeta !== void 0) callArgs.noMeta = flags.noMeta;
+		if (flags.retry !== void 0) callArgs.retry = flags.retry;
+		const out = await runTeamGet(callArgs);
+		if (!flags.json) process.stdout.write(out.stdout);
+		if (out.stderr) process.stderr.write(out.stderr);
+		if (out.exitCode !== 0) process.exitCode = out.exitCode;
+		return JSON.parse(out.stdout);
+	}
+};
+//#endregion
+export { TeamGet as default, runTeamGet };

package/dist/commands/team/list.js

@@ -0,0 +1,73 @@
+import { BASE_FLAGS, runCommand } from "../../lib/workspace-runtime.js";
+import { PAGINATION_FLAGS } from "../../core/pagination/flags.js";
+import "../../core/pagination/index.js";
+import { teamListRuntime } from "../../lib/team-list-runtime.js";
+import { Command, Flags } from "@oclif/core";
+//#region src/commands/team/list.ts
+/**
+* `linmux team list` -- Phase 2 PLAN 02-09 Task 1, TEM-01.list.
+*
+* Read command. Lists workspace-scoped teams. Implementation lives in
+* `src/lib/team-list-runtime.ts` per the Phase 1 PLAN-04 invariant (oclif
+* scans every file under `src/commands/` as a Command class).
+*
+* Exports BOTH the default Command class AND a named `runTeamList(args)`
+* function.
+*/
+async function runTeamList(args) {
+	const runArgs = {
+		commandPath: "team list",
+		pretty: args.pretty,
+		handler: async (retryOpts) => {
+			const runtimeFlags = {};
+			if (args.workspace !== void 0) runtimeFlags.workspace = args.workspace;
+			if (args.fields !== void 0) runtimeFlags.fields = args.fields;
+			if (args.limit !== void 0) runtimeFlags.limit = args.limit;
+			if (args.cursor !== void 0) runtimeFlags.cursor = args.cursor;
+			const result = await teamListRuntime({
+				flags: runtimeFlags,
+				env: process.env,
+				retryOptsOverride: retryOpts
+			});
+			return {
+				data: result.data,
+				meta: result.meta
+			};
+		}
+	};
+	if (args.noMeta !== void 0) runArgs.noMeta = args.noMeta;
+	if (args.quiet !== void 0) runArgs.quiet = args.quiet;
+	if (args.retry !== void 0) runArgs.retry = args.retry;
+	return runCommand(runArgs);
+}
+var TeamList = class TeamList extends Command {
+	static description = "List Linear teams in the resolved workspace.";
+	static enableJsonFlag = true;
+	static flags = {
+		...BASE_FLAGS,
+		...PAGINATION_FLAGS,
+		workspace: Flags.string({ description: "Workspace name (overrides active default and LINEAR_WORKSPACE)" }),
+		fields: Flags.string({
+			description: "Field preset (ids|defaults|full) or comma-separated list",
+			default: "defaults"
+		})
+	};
+	async run() {
+		const { flags } = await this.parse(TeamList);
+		const callArgs = { pretty: flags.pretty };
+		if (flags.workspace !== void 0) callArgs.workspace = flags.workspace;
+		if (flags.fields !== void 0) callArgs.fields = flags.fields;
+		if (flags.limit !== void 0) callArgs.limit = flags.limit;
+		if (flags.cursor !== void 0) callArgs.cursor = flags.cursor;
+		if (flags.quiet !== void 0) callArgs.quiet = flags.quiet;
+		if (flags.noMeta !== void 0) callArgs.noMeta = flags.noMeta;
+		if (flags.retry !== void 0) callArgs.retry = flags.retry;
+		const out = await runTeamList(callArgs);
+		if (!flags.json) process.stdout.write(out.stdout);
+		if (out.stderr) process.stderr.write(out.stderr);
+		if (out.exitCode !== 0) process.exitCode = out.exitCode;
+		return JSON.parse(out.stdout);
+	}
+};
+//#endregion
+export { TeamList as default, runTeamList };

package/dist/commands/whoami.js

@@ -0,0 +1,71 @@
+import { BASE_FLAGS, runCommand } from "../lib/workspace-runtime.js";
+import { meRuntime } from "../lib/me-runtime.js";
+import { Command, Flags } from "@oclif/core";
+//#region src/commands/whoami.ts
+/**
+* `linmux whoami` -- Phase 2 PLAN 02-09 Task 1, WHO-01.
+*
+* Alias for `me` -- prints the resolved viewer (user) and organization for
+* the current workspace. Shares `src/lib/me-runtime.ts` with `me`. Both
+* commands emit IDENTICAL envelopes except for `meta.command` (`'me'` vs
+* `'whoami'`). `whoami` exists purely for discoverability per CONTEXT
+* § Specifics line 65 (the pretty-alias pattern).
+*
+* Exports BOTH the default Command class AND a named `runWhoami(args)`
+* function.
+*/
+async function runWhoami(args) {
+	const runArgs = {
+		commandPath: "whoami",
+		pretty: args.pretty,
+		handler: async (retryOpts) => {
+			const runtimeFlags = {};
+			if (args.workspace !== void 0) runtimeFlags.workspace = args.workspace;
+			if (args.fields !== void 0) runtimeFlags.fields = args.fields;
+			const meInput = {
+				flags: runtimeFlags,
+				env: process.env,
+				retryOptsOverride: retryOpts
+			};
+			if (args.loadConfigOverride !== void 0) meInput.loadConfigOverride = args.loadConfigOverride;
+			if (args.clientFactoryOverride !== void 0) meInput.clientFactoryOverride = args.clientFactoryOverride;
+			const result = await meRuntime(meInput);
+			return {
+				data: result.data,
+				meta: result.meta
+			};
+		}
+	};
+	if (args.noMeta !== void 0) runArgs.noMeta = args.noMeta;
+	if (args.quiet !== void 0) runArgs.quiet = args.quiet;
+	if (args.retry !== void 0) runArgs.retry = args.retry;
+	return runCommand(runArgs);
+}
+var Whoami = class Whoami extends Command {
+	static description = "Alias for `me` -- prints the resolved viewer + organization.";
+	static enableJsonFlag = true;
+	static flags = {
+		...BASE_FLAGS,
+		workspace: Flags.string({ description: "Workspace name (overrides active default and LINEAR_WORKSPACE)" }),
+		fields: Flags.string({
+			description: "Field preset (ids|defaults|full) or comma-separated list",
+			default: "defaults"
+		})
+	};
+	async run() {
+		const { flags } = await this.parse(Whoami);
+		const callArgs = { pretty: flags.pretty };
+		if (flags.workspace !== void 0) callArgs.workspace = flags.workspace;
+		if (flags.fields !== void 0) callArgs.fields = flags.fields;
+		if (flags.quiet !== void 0) callArgs.quiet = flags.quiet;
+		if (flags.noMeta !== void 0) callArgs.noMeta = flags.noMeta;
+		if (flags.retry !== void 0) callArgs.retry = flags.retry;
+		const out = await runWhoami(callArgs);
+		if (!flags.json) process.stdout.write(out.stdout);
+		if (out.stderr) process.stderr.write(out.stderr);
+		if (out.exitCode !== 0) process.exitCode = out.exitCode;
+		return JSON.parse(out.stdout);
+	}
+};
+//#endregion
+export { Whoami as default, runWhoami };

package/dist/commands/workspace/add.js

@@ -0,0 +1,97 @@
+import { LinearAgentError } from "../../core/errors/error.js";
+import { withFetchInterception } from "../../core/transport/fetch-interceptor.js";
+import { withRateLimitRetry } from "../../core/transport/rate-limit.js";
+import "../../core/transport/index.js";
+import { BASE_FLAGS, runCommand } from "../../lib/workspace-runtime.js";
+import { createLinearClient } from "../../core/client/factory.js";
+import "../../core/client/index.js";
+import { loadConfig, saveConfig } from "../../core/config/store.js";
+import "../../core/config/index.js";
+import { Args, Command, Flags } from "@oclif/core";
+//#region src/commands/workspace/add.ts
+async function runWorkspaceAdd(args) {
+	const runArgs = {
+		commandPath: "workspace add",
+		pretty: args.pretty,
+		handler: async (retryOpts) => {
+			const config = loadConfig();
+			if (Object.hasOwn(config.workspaces, args.name)) throw LinearAgentError.workspace.alreadyExists(args.name);
+			const client = createLinearClient({
+				name: null,
+				token: args.token,
+				organizationId: null,
+				source: "api-key-env"
+			});
+			const effectiveRetryOpts = args.retryOptsOverride ?? retryOpts;
+			const orgId = await withFetchInterception(async () => {
+				const viewer = await withRateLimitRetry(() => client.viewer, effectiveRetryOpts);
+				return (await withRateLimitRetry(() => viewer.organization, effectiveRetryOpts)).id;
+			});
+			let warning;
+			const collision = Object.values(config.workspaces).find((w) => w.organizationId === orgId);
+			if (collision) warning = `organization already registered as ${collision.name}`;
+			const createdAt = (/* @__PURE__ */ new Date()).toISOString();
+			const entry = {
+				name: args.name,
+				token: args.token,
+				organizationId: orgId,
+				createdAt
+			};
+			const isActive = Object.keys(config.workspaces).length === 0;
+			saveConfig({
+				active: isActive ? args.name : config.active,
+				workspaces: {
+					...config.workspaces,
+					[args.name]: entry
+				}
+			});
+			return {
+				data: {
+					name: args.name,
+					organizationId: orgId,
+					isActive,
+					createdAt,
+					...warning !== void 0 ? { warning } : {}
+				},
+				meta: { workspace: args.name }
+			};
+		}
+	};
+	if (args.noMeta !== void 0) runArgs.noMeta = args.noMeta;
+	if (args.quiet !== void 0) runArgs.quiet = args.quiet;
+	if (args.retry !== void 0) runArgs.retry = args.retry;
+	return runCommand(runArgs);
+}
+var WorkspaceAdd = class WorkspaceAdd extends Command {
+	static description = "Register a Linear workspace";
+	static enableJsonFlag = true;
+	static args = { name: Args.string({
+		required: true,
+		description: "Local alias for the workspace"
+	}) };
+	static flags = {
+		token: Flags.string({
+			required: true,
+			description: "Linear personal API key (lin_api_*)"
+		}),
+		...BASE_FLAGS
+	};
+	async run() {
+		const { args, flags } = await this.parse(WorkspaceAdd);
+		const callArgs = {
+			name: args.name,
+			token: flags.token,
+			pretty: flags.pretty
+		};
+		if (flags.quiet !== void 0) callArgs.quiet = flags.quiet;
+		if (flags.noMeta !== void 0) callArgs.noMeta = flags.noMeta;
+		if (flags.retry !== void 0) callArgs.retry = flags.retry;
+		const out = await runWorkspaceAdd(callArgs);
+		if (!flags.json) process.stdout.write(out.stdout);
+		if (out.stderr) process.stderr.write(out.stderr);
+		if (out.exitCode !== 0) process.exitCode = out.exitCode;
+		return JSON.parse(out.stdout);
+	}
+};
+//#endregion
+export { WorkspaceAdd as default, runWorkspaceAdd };

package/dist/commands/workspace/list.js

@@ -0,0 +1,47 @@
+import { BASE_FLAGS, runCommand } from "../../lib/workspace-runtime.js";
+import { loadConfig } from "../../core/config/store.js";
+import "../../core/config/index.js";
+import { Command } from "@oclif/core";
+//#region src/commands/workspace/list.ts
+async function runWorkspaceList(args) {
+	const runArgs = {
+		commandPath: "workspace list",
+		pretty: args.pretty,
+		handler: async (_retryOpts) => {
+			const config = loadConfig();
+			return {
+				data: { workspaces: Object.values(config.workspaces).sort((a, b) => a.name.localeCompare(b.name)).map((w) => ({
+					name: w.name,
+					organizationId: w.organizationId,
+					isActive: config.active === w.name,
+					createdAt: w.createdAt,
+					...w.lastUsedAt !== void 0 ? { lastUsedAt: w.lastUsedAt } : {}
+				})) },
+				meta: {}
+			};
+		}
+	};
+	if (args.noMeta !== void 0) runArgs.noMeta = args.noMeta;
+	if (args.quiet !== void 0) runArgs.quiet = args.quiet;
+	if (args.retry !== void 0) runArgs.retry = args.retry;
+	return runCommand(runArgs);
+}
+var WorkspaceList = class WorkspaceList extends Command {
+	static description = "List registered Linear workspaces";
+	static enableJsonFlag = true;
+	static flags = { ...BASE_FLAGS };
+	async run() {
+		const { flags } = await this.parse(WorkspaceList);
+		const callArgs = { pretty: flags.pretty };
+		if (flags.quiet !== void 0) callArgs.quiet = flags.quiet;
+		if (flags.noMeta !== void 0) callArgs.noMeta = flags.noMeta;
+		if (flags.retry !== void 0) callArgs.retry = flags.retry;
+		const out = await runWorkspaceList(callArgs);
+		if (!flags.json) process.stdout.write(out.stdout);
+		if (out.stderr) process.stderr.write(out.stderr);
+		if (out.exitCode !== 0) process.exitCode = out.exitCode;
+		return JSON.parse(out.stdout);
+	}
+};
+//#endregion
+export { WorkspaceList as default, runWorkspaceList };