@ebragas/linear-cli 0.9.0

package/dist/cli.js

@@ -0,0 +1,2321 @@
+#!/usr/bin/env node
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+
+// src/cli.ts
+var import_commander = require("commander");
+var import_fs7 = require("fs");
+var import_path4 = require("path");
+
+// src/commands/auth.ts
+var import_http = __toESM(require("http"));
+var import_sdk = require("@linear/sdk");
+
+// src/credentials.ts
+var import_fs = require("fs");
+var import_path = require("path");
+var import_os = require("os");
+var REQUIRED_FIELDS = [
+  "authMethod",
+  "clientId",
+  "clientSecret",
+  "accessToken",
+  "tokenExpiresAt",
+  "actorId",
+  "workspaceId",
+  "workspaceSlug"
+];
+function getCredentialsDir(opts) {
+  const dir = opts?.credentialsDir ?? process.env.LINEAR_AGENT_CREDENTIALS_DIR ?? (0, import_path.join)((0, import_os.homedir)(), ".linear", "credentials");
+  return dir.startsWith("~") ? (0, import_path.join)((0, import_os.homedir)(), dir.slice(2)) : (0, import_path.resolve)(dir);
+}
+function credentialsPath(agentId, credentialsDir) {
+  return (0, import_path.join)(credentialsDir, `${agentId}.json`);
+}
+function readCredentials(agentId, credentialsDir) {
+  const path = credentialsPath(agentId, credentialsDir);
+  let raw;
+  try {
+    raw = (0, import_fs.readFileSync)(path, "utf-8");
+  } catch {
+    throw new Error(
+      `Credentials not found for agent "${agentId}" at ${path}. Run "linear auth setup" first.`
+    );
+  }
+  const data = JSON.parse(raw);
+  const missing = REQUIRED_FIELDS.filter(
+    (f) => data[f] === void 0 || data[f] === null
+  );
+  if (missing.length > 0) {
+    throw new Error(
+      `Credentials file missing required fields: ${missing.join(", ")}`
+    );
+  }
+  return data;
+}
+function writeCredentials(agentId, credentialsDir, data) {
+  (0, import_fs.mkdirSync)(credentialsDir, { recursive: true, mode: 448 });
+  const path = credentialsPath(agentId, credentialsDir);
+  (0, import_fs.writeFileSync)(path, JSON.stringify(data, null, 2) + "\n", {
+    mode: 384
+  });
+}
+function deleteCredentials(agentId, credentialsDir) {
+  const path = credentialsPath(agentId, credentialsDir);
+  try {
+    const { unlinkSync } = require("fs");
+    unlinkSync(path);
+  } catch {
+  }
+}
+
+// src/errors.ts
+var CLIError = class extends Error {
+  constructor(message, exitCode, resolution) {
+    super(message);
+    this.exitCode = exitCode;
+    this.resolution = resolution;
+    this.name = this.constructor.name;
+  }
+};
+var RateLimitError = class extends CLIError {
+  constructor(message, resetAt) {
+    super(message, 1, "Wait for rate limit reset or reduce request frequency.");
+    this.resetAt = resetAt;
+  }
+};
+var AuthenticationError = class extends CLIError {
+  constructor(message) {
+    super(message, 2, 'Run "linear auth setup" to re-authenticate.');
+  }
+};
+var ForbiddenError = class extends CLIError {
+  constructor(message) {
+    super(
+      message,
+      3,
+      "The agent may have lost access. Check team permissions in Linear."
+    );
+  }
+};
+var ValidationError = class extends CLIError {
+  constructor(message, validOptions) {
+    const resolution = validOptions?.length ? `Valid options:
+${validOptions.map((o) => `  - ${o}`).join("\n")}` : void 0;
+    super(message, 4, resolution);
+    this.validOptions = validOptions;
+  }
+};
+var NetworkError = class extends CLIError {
+  constructor(message) {
+    super(message, 5, "Check network connectivity and try again.");
+  }
+};
+var PartialSuccessError = class extends CLIError {
+  constructor(message, succeeded, failed) {
+    super(message, 6);
+    this.succeeded = succeeded;
+    this.failed = failed;
+  }
+};
+function classifyError(err) {
+  if (err instanceof CLIError) return err;
+  const message = err instanceof Error ? err.message : String(err);
+  const errObj = err;
+  const type = errObj?.type ?? errObj?.extensions?.code;
+  switch (type) {
+    case "RATELIMITED":
+      return new RateLimitError(message);
+    case "AUTHENTICATION_ERROR":
+      return new AuthenticationError(message);
+    case "FORBIDDEN":
+      return new ForbiddenError(message);
+    case "InvalidInputLinearError":
+      return new ValidationError(message);
+    default:
+      if (message.includes("ECONNREFUSED") || message.includes("ENOTFOUND") || message.includes("ETIMEDOUT") || message.includes("fetch failed")) {
+        return new NetworkError(message);
+      }
+      return new CLIError(message, 1);
+  }
+}
+
+// src/output.ts
+function getFormat(formatFlag) {
+  if (formatFlag === "json" || formatFlag === "text") return formatFlag;
+  return process.stdout.isTTY ? "text" : "json";
+}
+function formatOutput(result, format) {
+  if (format === "json") {
+    return formatJson(result);
+  }
+  return formatText(result);
+}
+function formatJson(result) {
+  const { data, warnings } = result;
+  if (Array.isArray(data)) {
+    const obj = { results: data };
+    if (warnings?.length) obj.warnings = warnings;
+    return JSON.stringify(obj, null, 2);
+  }
+  if (warnings?.length) {
+    return JSON.stringify({ ...data, _warnings: warnings }, null, 2);
+  }
+  return JSON.stringify(data, null, 2);
+}
+function formatText(result) {
+  const { data, warnings } = result;
+  const lines = [];
+  if (Array.isArray(data)) {
+    for (const item of data) {
+      lines.push(formatRecord(item));
+    }
+  } else if (data && typeof data === "object") {
+    lines.push(formatRecord(data));
+  } else {
+    lines.push(String(data));
+  }
+  if (warnings?.length) {
+    lines.push("");
+    for (const w of warnings) {
+      lines.push(`Warning: ${w}`);
+    }
+  }
+  return lines.join("\n");
+}
+function formatRecord(item) {
+  if (!item || typeof item !== "object") return String(item);
+  const record = item;
+  return Object.entries(record).map(([key, value]) => {
+    if (value === null || value === void 0) return `${key}: -`;
+    if (typeof value === "object") return `${key}: ${JSON.stringify(value)}`;
+    return `${key}: ${value}`;
+  }).join("\n");
+}
+function printResult(result, format) {
+  console.log(formatOutput(result, format));
+}
+
+// src/commands/auth.ts
+var TOKEN_URL = "https://api.linear.app/oauth/token";
+var AUTHORIZE_URL = "https://linear.app/oauth/authorize";
+var DEFAULT_SCOPES = "read,write,app:assignable,app:mentionable";
+async function fetchToken(params) {
+  const response = await fetch(TOKEN_URL, {
+    method: "POST",
+    headers: { "Content-Type": "application/x-www-form-urlencoded" },
+    body: new URLSearchParams(params).toString()
+  });
+  if (!response.ok) {
+    const body = await response.text();
+    throw new AuthenticationError(
+      `Token request failed: ${response.status} ${response.statusText}
+${body}`
+    );
+  }
+  return await response.json();
+}
+async function fetchViewerAndOrg(accessToken) {
+  const client = new import_sdk.LinearClient({ accessToken });
+  const viewer = await client.viewer;
+  const org = await client.organization;
+  return {
+    actorId: viewer.id,
+    name: viewer.name ?? viewer.id,
+    workspaceId: org.id,
+    workspaceSlug: org.urlKey
+  };
+}
+async function setupClientCredentials(opts) {
+  const tokenData = await fetchToken({
+    grant_type: "client_credentials",
+    client_id: opts.clientId,
+    client_secret: opts.clientSecret,
+    scope: opts.scopes
+  });
+  const { actorId, name, workspaceId, workspaceSlug } = await fetchViewerAndOrg(tokenData.access_token);
+  const credentials = {
+    authMethod: "client_credentials",
+    clientId: opts.clientId,
+    clientSecret: opts.clientSecret,
+    accessToken: tokenData.access_token,
+    refreshToken: null,
+    tokenExpiresAt: new Date(
+      Date.now() + tokenData.expires_in * 1e3
+    ).toISOString(),
+    actorId,
+    workspaceId,
+    workspaceSlug
+  };
+  writeCredentials(opts.agent, opts.credentialsDir, credentials);
+  const format = getFormat(opts.format);
+  printResult(
+    {
+      data: {
+        status: "authenticated",
+        agent: opts.agent,
+        actorId,
+        name,
+        workspace: workspaceSlug,
+        expiresAt: credentials.tokenExpiresAt
+      }
+    },
+    format
+  );
+}
+async function setupOAuth(opts) {
+  const redirectUri = `http://localhost:${opts.port}/callback`;
+  const code = await new Promise((resolve3, reject) => {
+    const server = import_http.default.createServer((req, res) => {
+      const url = new URL(req.url ?? "/", `http://localhost:${opts.port}`);
+      if (url.pathname === "/callback") {
+        const code2 = url.searchParams.get("code");
+        const error = url.searchParams.get("error");
+        if (error) {
+          res.writeHead(400, { "Content-Type": "text/html" });
+          res.end(`<h1>Authorization failed</h1><p>${error}</p>`);
+          server.close();
+          reject(
+            new AuthenticationError(`OAuth authorization failed: ${error}`)
+          );
+          return;
+        }
+        if (code2) {
+          res.writeHead(200, { "Content-Type": "text/html" });
+          res.end(
+            "<h1>Authorization successful</h1><p>You can close this window.</p>"
+          );
+          server.close();
+          resolve3(code2);
+          return;
+        }
+      }
+      res.writeHead(404);
+      res.end("Not found");
+    });
+    server.listen(opts.port, () => {
+      const authUrl = new URL(AUTHORIZE_URL);
+      authUrl.searchParams.set("response_type", "code");
+      authUrl.searchParams.set("client_id", opts.clientId);
+      authUrl.searchParams.set("redirect_uri", redirectUri);
+      authUrl.searchParams.set("scope", opts.scopes);
+      authUrl.searchParams.set("actor", "app");
+      console.log(`
+Open this URL in your browser:
+${authUrl.toString()}
+`);
+      console.log(`Waiting for callback on port ${opts.port}...`);
+    });
+    server.on("error", (err) => {
+      reject(
+        new AuthenticationError(
+          `Failed to start callback server: ${err.message}`
+        )
+      );
+    });
+    setTimeout(() => {
+      server.close();
+      reject(new AuthenticationError("OAuth callback timed out after 5 minutes"));
+    }, 5 * 60 * 1e3);
+  });
+  const tokenData = await fetchToken({
+    grant_type: "authorization_code",
+    code,
+    redirect_uri: redirectUri,
+    client_id: opts.clientId,
+    client_secret: opts.clientSecret
+  });
+  const { actorId, name, workspaceId, workspaceSlug } = await fetchViewerAndOrg(tokenData.access_token);
+  const credentials = {
+    authMethod: "oauth",
+    clientId: opts.clientId,
+    clientSecret: opts.clientSecret,
+    accessToken: tokenData.access_token,
+    refreshToken: tokenData.refresh_token ?? null,
+    tokenExpiresAt: new Date(
+      Date.now() + tokenData.expires_in * 1e3
+    ).toISOString(),
+    actorId,
+    workspaceId,
+    workspaceSlug
+  };
+  writeCredentials(opts.agent, opts.credentialsDir, credentials);
+  const format = getFormat(opts.format);
+  printResult(
+    {
+      data: {
+        status: "authenticated",
+        agent: opts.agent,
+        actorId,
+        name,
+        workspace: workspaceSlug,
+        method: "oauth",
+        expiresAt: credentials.tokenExpiresAt
+      }
+    },
+    format
+  );
+}
+function registerAuthCommands(program2) {
+  const auth = program2.command("auth").description("Manage authentication and API tokens");
+  auth.command("setup").description("Authenticate an agent with Linear").requiredOption("--client-id <id>", "OAuth application client ID").requiredOption("--client-secret <secret>", "OAuth application client secret").option("--client-credentials", "Use client credentials grant (default)", true).option("--oauth", "Use OAuth authorization code flow").option("--port <port>", "Local callback server port (OAuth only)", "9876").option("--scopes <scopes>", "OAuth scopes", DEFAULT_SCOPES).action(async (opts, cmd) => {
+    const globalOpts = cmd.optsWithGlobals();
+    const agent = globalOpts.agent;
+    if (!agent) {
+      console.error(
+        "Error: --agent is required (or set LINEAR_AGENT_ID env var)"
+      );
+      process.exit(4);
+    }
+    const credentialsDir = getCredentialsDir(globalOpts);
+    const format = globalOpts.format;
+    if (opts.oauth) {
+      await setupOAuth({
+        agent,
+        clientId: opts.clientId,
+        clientSecret: opts.clientSecret,
+        scopes: opts.scopes,
+        port: parseInt(opts.port, 10),
+        credentialsDir,
+        format
+      });
+    } else {
+      await setupClientCredentials({
+        agent,
+        clientId: opts.clientId,
+        clientSecret: opts.clientSecret,
+        scopes: opts.scopes,
+        credentialsDir,
+        format
+      });
+    }
+  });
+  auth.command("whoami").description("Verify token and print agent identity").action(async (_opts, cmd) => {
+    const globalOpts = cmd.optsWithGlobals();
+    const agent = globalOpts.agent;
+    if (!agent) {
+      console.error(
+        "Error: --agent is required (or set LINEAR_AGENT_ID env var)"
+      );
+      process.exit(4);
+    }
+    const credentialsDir = getCredentialsDir(globalOpts);
+    const credentials = readCredentials(agent, credentialsDir);
+    const client = new import_sdk.LinearClient({
+      accessToken: credentials.accessToken
+    });
+    const viewer = await client.viewer;
+    const org = await client.organization;
+    const format = getFormat(globalOpts.format);
+    printResult(
+      {
+        data: {
+          agent,
+          actorId: credentials.actorId,
+          name: viewer.name ?? viewer.id,
+          email: viewer.email,
+          workspace: org.urlKey,
+          workspaceId: org.id,
+          authMethod: credentials.authMethod,
+          tokenExpiresAt: credentials.tokenExpiresAt
+        }
+      },
+      format
+    );
+  });
+  auth.command("refresh").description("Request a new token").action(async (_opts, cmd) => {
+    const globalOpts = cmd.optsWithGlobals();
+    const agent = globalOpts.agent;
+    if (!agent) {
+      console.error(
+        "Error: --agent is required (or set LINEAR_AGENT_ID env var)"
+      );
+      process.exit(4);
+    }
+    const credentialsDir = getCredentialsDir(globalOpts);
+    const credentials = readCredentials(agent, credentialsDir);
+    const params = {
+      client_id: credentials.clientId,
+      client_secret: credentials.clientSecret
+    };
+    if (credentials.authMethod === "client_credentials") {
+      params.grant_type = "client_credentials";
+      params.scope = "read,write,app:assignable,app:mentionable";
+    } else {
+      params.grant_type = "refresh_token";
+      params.refresh_token = credentials.refreshToken ?? "";
+    }
+    const tokenData = await fetchToken(params);
+    const updated = {
+      ...credentials,
+      accessToken: tokenData.access_token,
+      refreshToken: tokenData.refresh_token ?? credentials.refreshToken,
+      tokenExpiresAt: new Date(
+        Date.now() + tokenData.expires_in * 1e3
+      ).toISOString()
+    };
+    writeCredentials(agent, credentialsDir, updated);
+    const format = getFormat(globalOpts.format);
+    printResult(
+      {
+        data: {
+          status: "refreshed",
+          agent,
+          expiresAt: updated.tokenExpiresAt
+        }
+      },
+      format
+    );
+  });
+  auth.command("revoke").description("Revoke token and delete credentials").action(async (_opts, cmd) => {
+    const globalOpts = cmd.optsWithGlobals();
+    const agent = globalOpts.agent;
+    if (!agent) {
+      console.error(
+        "Error: --agent is required (or set LINEAR_AGENT_ID env var)"
+      );
+      process.exit(4);
+    }
+    const credentialsDir = getCredentialsDir(globalOpts);
+    let credentials;
+    try {
+      credentials = readCredentials(agent, credentialsDir);
+    } catch {
+      console.error(`No credentials found for agent "${agent}".`);
+      process.exit(4);
+    }
+    try {
+      const response = await fetch(
+        "https://api.linear.app/oauth/revoke",
+        {
+          method: "POST",
+          headers: {
+            "Content-Type": "application/x-www-form-urlencoded",
+            Authorization: `Bearer ${credentials.accessToken}`
+          }
+        }
+      );
+      if (!response.ok) {
+        console.error(
+          `Warning: Token revocation returned ${response.status} (token may already be expired)`
+        );
+      }
+    } catch {
+      console.error(
+        "Warning: Could not reach Linear API to revoke token"
+      );
+    }
+    deleteCredentials(agent, credentialsDir);
+    const format = getFormat(globalOpts.format);
+    printResult(
+      {
+        data: {
+          status: "revoked",
+          agent
+        }
+      },
+      format
+    );
+  });
+}
+
+// src/commands/issue.ts
+var import_fs3 = require("fs");
+
+// src/cache.ts
+var import_fs2 = require("fs");
+var import_path2 = require("path");
+var TTL_MS = 24 * 60 * 60 * 1e3;
+function cachePath(agentId, credentialsDir) {
+  return (0, import_path2.join)(credentialsDir, `${agentId}.cache.json`);
+}
+function readCache(agentId, credentialsDir) {
+  const path = cachePath(agentId, credentialsDir);
+  try {
+    const raw = (0, import_fs2.readFileSync)(path, "utf-8");
+    return JSON.parse(raw);
+  } catch {
+    return { teams: {} };
+  }
+}
+function writeCache(agentId, credentialsDir, cache) {
+  (0, import_fs2.mkdirSync)(credentialsDir, { recursive: true });
+  const path = cachePath(agentId, credentialsDir);
+  (0, import_fs2.writeFileSync)(path, JSON.stringify(cache, null, 2) + "\n");
+}
+function getTeamStates(cache, teamKey) {
+  const team = cache.teams[teamKey];
+  if (!team) return null;
+  const age = Date.now() - new Date(team.updatedAt).getTime();
+  if (age > TTL_MS) return null;
+  return team.states;
+}
+function setTeamStates(cache, teamKey, states) {
+  return {
+    ...cache,
+    teams: {
+      ...cache.teams,
+      [teamKey]: {
+        states,
+        updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+      }
+    }
+  };
+}
+
+// src/resolvers.ts
+var userCache = null;
+function parseTeamKey(issueIdentifier) {
+  const match = issueIdentifier.match(/^([A-Z][A-Z0-9]*)-\d+$/);
+  if (!match) {
+    throw new ValidationError(
+      `Cannot parse team key from identifier "${issueIdentifier}". Expected format: TEAM-123`
+    );
+  }
+  return match[1];
+}
+async function resolveUser(value, credentials, client) {
+  if (value.toLowerCase() === "me") {
+    return credentials.actorId;
+  }
+  if (/^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i.test(
+    value
+  )) {
+    return value;
+  }
+  if (!userCache) {
+    userCache = /* @__PURE__ */ new Map();
+    const users = await client.users();
+    for (const u of users.nodes) {
+      if (u.name) userCache.set(u.name.toLowerCase(), u.id);
+      if (u.email) userCache.set(u.email.toLowerCase(), u.id);
+      if (u.displayName) userCache.set(u.displayName.toLowerCase(), u.id);
+    }
+  }
+  const id = userCache.get(value.toLowerCase());
+  if (id) return id;
+  const validOptions = Array.from(userCache.keys());
+  throw new ValidationError(
+    `No user matching "${value}"`,
+    validOptions.slice(0, 20)
+  );
+}
+async function resolveState(name, teamKey, client, agentId, credentialsDir) {
+  if (/^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i.test(
+    name
+  )) {
+    return name;
+  }
+  let cache = readCache(agentId, credentialsDir);
+  let states = getTeamStates(cache, teamKey);
+  if (!states) {
+    states = await fetchTeamStates(teamKey, client);
+    cache = setTeamStates(cache, teamKey, states);
+    writeCache(agentId, credentialsDir, cache);
+  }
+  const nameLower = name.toLowerCase();
+  for (const [stateName, stateId] of Object.entries(states)) {
+    if (stateName.toLowerCase() === nameLower) return stateId;
+  }
+  throw new ValidationError(
+    `No workflow state "${name}" found for team ${teamKey}`,
+    Object.keys(states)
+  );
+}
+async function fetchTeamStates(teamKey, client) {
+  const teams = await client.teams({ filter: { key: { eq: teamKey } } });
+  const team = teams.nodes[0];
+  if (!team) {
+    throw new ValidationError(`Team "${teamKey}" not found`);
+  }
+  const workflowStates = await team.states();
+  const states = {};
+  for (const s of workflowStates.nodes) {
+    states[s.name] = s.id;
+  }
+  return states;
+}
+
+// src/client.ts
+var import_sdk2 = require("@linear/sdk");
+async function refreshToken(credentials, agentId, credentialsDir) {
+  const body = {
+    client_id: credentials.clientId,
+    client_secret: credentials.clientSecret
+  };
+  if (credentials.authMethod === "client_credentials") {
+    body.grant_type = "client_credentials";
+    body.scope = "read,write,app:assignable,app:mentionable";
+  } else {
+    body.grant_type = "refresh_token";
+    body.refresh_token = credentials.refreshToken ?? "";
+  }
+  const response = await fetch("https://api.linear.app/oauth/token", {
+    method: "POST",
+    headers: { "Content-Type": "application/x-www-form-urlencoded" },
+    body: new URLSearchParams(body).toString()
+  });
+  if (!response.ok) {
+    throw new AuthenticationError(
+      `Token refresh failed: ${response.status} ${response.statusText}`
+    );
+  }
+  const data = await response.json();
+  const expiresAt = new Date(
+    Date.now() + data.expires_in * 1e3
+  ).toISOString();
+  const updated = {
+    ...credentials,
+    accessToken: data.access_token,
+    tokenExpiresAt: expiresAt,
+    refreshToken: data.refresh_token ?? credentials.refreshToken
+  };
+  writeCredentials(agentId, credentialsDir, updated);
+  return updated;
+}
+function isRateLimited(err) {
+  const errObj = err;
+  const extensions = errObj?.extensions;
+  const type = errObj?.type ?? extensions?.code ?? "";
+  if (type === "RATELIMITED") {
+    const reset = extensions?.rateLimit;
+    return reset?.reset ?? true;
+  }
+  const errors = errObj?.errors;
+  if (errors?.some((e) => e.extensions?.code === "RATELIMITED")) {
+    return true;
+  }
+  return false;
+}
+function isAuthError(err) {
+  const errObj = err;
+  const type = errObj?.type ?? errObj?.extensions?.code;
+  if (type === "AUTHENTICATION_ERROR") return true;
+  const message = errObj?.message;
+  return message?.includes("AUTHENTICATION_ERROR") ?? false;
+}
+function isNetworkError(err) {
+  const message = err instanceof Error ? err.message : String(err);
+  return message.includes("ECONNREFUSED") || message.includes("ENOTFOUND") || message.includes("ETIMEDOUT") || message.includes("fetch failed") || message.includes("network");
+}
+function sleep(ms) {
+  return new Promise((resolve3) => setTimeout(resolve3, ms));
+}
+async function withRetry(fn, credentials, agentId, credentialsDir) {
+  const client = createClient(credentials);
+  try {
+    return await fn(client);
+  } catch (err) {
+    const rateLimitResult = isRateLimited(err);
+    if (rateLimitResult) {
+      if (typeof rateLimitResult === "number") {
+        const waitMs = Math.max(0, rateLimitResult - Date.now());
+        await sleep(Math.min(waitMs, 6e4));
+      } else {
+        await sleep(5e3);
+      }
+      try {
+        return await fn(client);
+      } catch {
+        throw new RateLimitError("Rate limited after retry");
+      }
+    }
+    if (isAuthError(err)) {
+      try {
+        const updated = await refreshToken(
+          credentials,
+          agentId,
+          credentialsDir
+        );
+        const newClient = createClient(updated);
+        return await fn(newClient);
+      } catch (refreshErr) {
+        if (refreshErr instanceof AuthenticationError) throw refreshErr;
+        throw new AuthenticationError(
+          "Token refresh failed. Run 'linear auth setup' to re-authenticate."
+        );
+      }
+    }
+    if (isNetworkError(err)) {
+      await sleep(2e3);
+      try {
+        return await fn(client);
+      } catch {
+        throw new NetworkError(
+          "Network error after retry. Check connectivity."
+        );
+      }
+    }
+    throw classifyError(err);
+  }
+}
+function createClient(credentials) {
+  return new import_sdk2.LinearClient({ accessToken: credentials.accessToken });
+}
+
+// src/context.ts
+function requireAgent(globalOpts) {
+  const agent = globalOpts.agent;
+  if (!agent) {
+    console.error(
+      "Error: --agent is required (or set LINEAR_AGENT_ID env var)"
+    );
+    process.exit(4);
+  }
+  return agent;
+}
+async function runWithClient(globalOpts, fn) {
+  const agentId = requireAgent(globalOpts);
+  const credentialsDir = getCredentialsDir(globalOpts);
+  const credentials = readCredentials(agentId, credentialsDir);
+  return withRetry(
+    (client) => fn(client, { credentials, agentId, credentialsDir }),
+    credentials,
+    agentId,
+    credentialsDir
+  );
+}
+
+// src/commands/issue.ts
+var FREQUENCY_MAP = {
+  daily: "days",
+  weekly: "weeks",
+  monthly: "months",
+  yearly: "years"
+};
+function parseDate(value) {
+  const durationMatch = value.match(/^-P(\d+)D$/);
+  if (durationMatch) {
+    const days = parseInt(durationMatch[1], 10);
+    const date = new Date(Date.now() - days * 24 * 60 * 60 * 1e3);
+    return date.toISOString();
+  }
+  return new Date(value).toISOString();
+}
+async function createRelations(client, issueId, blocks, blockedBy, relatedTo) {
+  const succeeded = [];
+  const failed = [];
+  const warnings = [];
+  const relations = [];
+  for (const targetId of blocks) {
+    relations.push({
+      relatedIssueId: targetId,
+      type: "blocks",
+      label: `blocks ${targetId}`
+    });
+  }
+  for (const targetId of blockedBy) {
+    relations.push({
+      relatedIssueId: targetId,
+      type: "blocks",
+      label: `blocked-by ${targetId}`
+    });
+  }
+  for (const targetId of relatedTo) {
+    relations.push({
+      relatedIssueId: targetId,
+      type: "related",
+      label: `related-to ${targetId}`
+    });
+  }
+  for (const rel of relations) {
+    try {
+      if (rel.label.startsWith("blocked-by")) {
+        await client.createIssueRelation({
+          issueId: rel.relatedIssueId,
+          relatedIssueId: issueId,
+          type: rel.type
+        });
+      } else {
+        await client.createIssueRelation({
+          issueId,
+          relatedIssueId: rel.relatedIssueId,
+          type: rel.type
+        });
+      }
+      succeeded.push(rel.label);
+    } catch (err) {
+      const msg = err instanceof Error ? err.message : String(err);
+      failed.push(rel.label);
+      warnings.push(`Failed to create relation "${rel.label}": ${msg}`);
+    }
+  }
+  return { succeeded, failed, warnings };
+}
+function collectArray(value, previous) {
+  return previous.concat([value]);
+}
+async function resolveLabels(client, labels) {
+  const labelIds = [];
+  for (const l of labels) {
+    if (/^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i.test(l)) {
+      labelIds.push(l);
+      continue;
+    }
+    const result = await client.issueLabels({
+      filter: { name: { eqIgnoreCase: l } }
+    });
+    if (!result.nodes[0]) {
+      throw new ValidationError(`No label matching "${l}"`);
+    }
+    labelIds.push(result.nodes[0].id);
+  }
+  return labelIds;
+}
+async function resolveProject(client, project) {
+  if (/^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i.test(project)) {
+    return project;
+  }
+  const projects = await client.projects({
+    filter: { name: { eqIgnoreCase: project } }
+  });
+  if (!projects.nodes[0]) {
+    throw new ValidationError(`No project matching "${project}"`);
+  }
+  return projects.nodes[0].id;
+}
+async function resolveTeam(client, team) {
+  if (/^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i.test(team)) {
+    return team;
+  }
+  const teams = await client.teams({
+    filter: { name: { eqIgnoreCase: team } }
+  });
+  if (!teams.nodes[0]) {
+    throw new ValidationError(`No team matching "${team}"`);
+  }
+  return teams.nodes[0].id;
+}
+function registerIssueCommands(program2) {
+  const issue = program2.command("issue").description("Create, read, update, and search issues");
+  issue.command("list").description("List issues with filters").option("--assignee <user>", "Filter by assignee (name, email, ID, or 'me')").option("--delegate <agent>", "Filter by delegated agent").option("--state <state>", "Filter by workflow state name or type").option("--label <label>", "Filter by label name").option("--team <team>", "Filter by team name or ID").option("--project <project>", "Filter by project name or ID").option("--priority <priority>", "Filter by priority (0-4)").option("--query <text>", "Search title/description").option("--created-after <date>", "ISO-8601 date or duration (e.g., -P7D)").option("--updated-after <date>", "ISO-8601 date or duration").option("--limit <n>", "Max results (default: 50, max: 250)", "50").option("--include-archived", "Include archived issues").action(async (opts, cmd) => {
+    const globalOpts = cmd.optsWithGlobals();
+    await runWithClient(globalOpts, async (client, { credentials }) => {
+      const format = getFormat(globalOpts.format);
+      const filter = {};
+      if (opts.assignee) {
+        const userId = await resolveUser(opts.assignee, credentials, client);
+        filter.assignee = { id: { eq: userId } };
+      }
+      if (opts.delegate) {
+        const userId = await resolveUser(opts.delegate, credentials, client);
+        filter.delegate = { id: { eq: userId } };
+      }
+      if (opts.state) {
+        filter.state = { name: { eqIgnoreCase: opts.state } };
+      }
+      if (opts.label) {
+        filter.labels = { name: { eqIgnoreCase: opts.label } };
+      }
+      if (opts.team) {
+        filter.team = { name: { eqIgnoreCase: opts.team } };
+      }
+      if (opts.project) {
+        filter.project = { name: { eqIgnoreCase: opts.project } };
+      }
+      if (opts.priority) {
+        filter.priority = { eq: parseInt(opts.priority, 10) };
+      }
+      if (opts.createdAfter) {
+        filter.createdAt = { gte: parseDate(opts.createdAfter) };
+      }
+      if (opts.updatedAfter) {
+        filter.updatedAt = { gte: parseDate(opts.updatedAfter) };
+      }
+      const limit = Math.min(parseInt(opts.limit, 10) || 50, 250);
+      const queryOpts = {
+        filter,
+        first: limit,
+        includeArchived: opts.includeArchived ?? false
+      };
+      if (opts.query) {
+        filter.or = [
+          { title: { containsIgnoreCase: opts.query } },
+          { description: { containsIgnoreCase: opts.query } }
+        ];
+      }
+      const issues = await client.issues(queryOpts);
+      const results = await Promise.all(
+        issues.nodes.map(async (i) => {
+          const state = await i.state;
+          return {
+            id: i.identifier,
+            title: i.title,
+            state: state?.name ?? null,
+            priority: i.priority,
+            url: i.url
+          };
+        })
+      );
+      printResult({ data: results }, format);
+    });
+  });
+  issue.command("get").description("Get full issue details").argument("<ids...>", "Issue identifier(s) (e.g., MAIN-42 MAIN-43)").action(async (ids, _opts, cmd) => {
+    const globalOpts = cmd.optsWithGlobals();
+    await runWithClient(globalOpts, async (client) => {
+      const format = getFormat(globalOpts.format);
+      const fetchIssue = async (id) => {
+        const issueObj = await client.issue(id);
+        const [state, assignee, delegate, labels, parent, children, comments, relations] = await Promise.all([
+          issueObj.state,
+          issueObj.assignee,
+          issueObj.delegate,
+          issueObj.labels(),
+          issueObj.parent,
+          issueObj.children(),
+          issueObj.comments(),
+          issueObj.relations()
+        ]);
+        return {
+          id: issueObj.identifier,
+          title: issueObj.title,
+          description: issueObj.description ?? null,
+          state: state?.name ?? null,
+          stateType: state?.type ?? null,
+          assignee: assignee ? { id: assignee.id, name: assignee.name } : null,
+          delegate: delegate ? { id: delegate.id, name: delegate.name } : null,
+          labels: labels.nodes.map((l) => ({ id: l.id, name: l.name })),
+          priority: issueObj.priority,
+          priorityLabel: issueObj.priorityLabel,
+          parent: parent ? { id: parent.identifier, title: parent.title } : null,
+          children: children.nodes.map((c) => ({
+            id: c.identifier,
+            title: c.title
+          })),
+          relations: relations.nodes.map((r) => ({
+            type: r.type,
+            relatedIssueId: r.relatedIssueId ?? null
+          })),
+          comments: comments.nodes.map((c) => ({
+            id: c.id,
+            body: c.body,
+            createdAt: c.createdAt
+          })),
+          dueDate: issueObj.dueDate ?? null,
+          estimate: issueObj.estimate ?? null,
+          url: issueObj.url
+        };
+      };
+      if (ids.length === 1) {
+        const result = await fetchIssue(ids[0]);
+        printResult({ data: result }, format);
+      } else {
+        const settled = await Promise.allSettled(ids.map(fetchIssue));
+        const results = [];
+        const warnings = [];
+        for (let i = 0; i < settled.length; i++) {
+          const outcome = settled[i];
+          if (outcome.status === "fulfilled") {
+            results.push(outcome.value);
+          } else {
+            const msg = outcome.reason instanceof Error ? outcome.reason.message : String(outcome.reason);
+            warnings.push(`${ids[i]}: ${msg}`);
+          }
+        }
+        printResult({ data: results, warnings: warnings.length ? warnings : void 0 }, format);
+      }
+    });
+  });
+  issue.command("create").description("Create a new issue").requiredOption("--title <text>", "Issue title").requiredOption("--team <team>", "Team name or ID").option("--description <text>", "Markdown description").option("--description-file <path>", "Read description from file").option("--assignee <user>", "Assign to user").option("--delegate <agent>", "Delegate to agent").option("--state <state>", "Initial workflow state").option("--label <label>", "Add label (repeatable)", collectArray, []).option("--priority <priority>", "Priority level (0-4)").option("--project <project>", "Add to project").option("--parent <id>", "Set parent issue").option("--blocks <id>", "This issue blocks <id> (repeatable)", collectArray, []).option("--blocked-by <id>", "This issue is blocked by <id> (repeatable)", collectArray, []).option("--related-to <id>", "Related issue (repeatable)", collectArray, []).option("--due-date <date>", "Due date (ISO format)").option("--estimate <n>", "Effort estimate").action(async (opts, cmd) => {
+    const globalOpts = cmd.optsWithGlobals();
+    await runWithClient(globalOpts, async (client, { credentials, agentId, credentialsDir }) => {
+      const format = getFormat(globalOpts.format);
+      const teamId = await resolveTeam(client, opts.team);
+      const input = {
+        title: opts.title,
+        teamId
+      };
+      if (opts.descriptionFile) {
+        input.description = (0, import_fs3.readFileSync)(opts.descriptionFile, "utf-8");
+      } else if (opts.description) {
+        input.description = opts.description;
+      } else if (!process.stdin.isTTY) {
+        try {
+          const stdinContent = (0, import_fs3.readFileSync)(0, "utf-8").trim();
+          if (stdinContent) input.description = stdinContent;
+        } catch (err) {
+          const message = err instanceof Error ? err.message : String(err);
+          console.error(`Error: Failed to read from stdin: ${message}`);
+          process.exit(4);
+        }
+      }
+      if (opts.assignee) {
+        input.assigneeId = await resolveUser(
+          opts.assignee,
+          credentials,
+          client
+        );
+      }
+      if (opts.delegate) {
+        input.delegateId = await resolveUser(
+          opts.delegate,
+          credentials,
+          client
+        );
+      }
+      if (opts.state) {
+        const team = await client.team(teamId);
+        input.stateId = await resolveState(
+          opts.state,
+          team.key,
+          client,
+          agentId,
+          credentialsDir
+        );
+      }
+      if (opts.label && opts.label.length > 0) {
+        input.labelIds = await resolveLabels(client, opts.label);
+      }
+      if (opts.priority !== void 0) {
+        input.priority = parseInt(opts.priority, 10);
+      }
+      if (opts.project) {
+        input.projectId = await resolveProject(client, opts.project);
+      }
+      if (opts.parent) {
+        input.parentId = opts.parent;
+      }
+      if (opts.dueDate) {
+        input.dueDate = opts.dueDate;
+      }
+      if (opts.estimate !== void 0) {
+        input.estimate = parseInt(opts.estimate, 10);
+      }
+      const payload = await client.createIssue(input);
+      const created = await payload.issue;
+      const result = {
+        id: created?.identifier ?? null,
+        title: created?.title ?? opts.title,
+        url: created?.url ?? null
+      };
+      const blocks = opts.blocks ?? [];
+      const blockedBy = opts.blockedBy ?? [];
+      const relatedTo = opts.relatedTo ?? [];
+      const hasRelations = blocks.length > 0 || blockedBy.length > 0 || relatedTo.length > 0;
+      if (hasRelations && created) {
+        const { succeeded, failed, warnings } = await createRelations(
+          client,
+          created.id,
+          blocks,
+          blockedBy,
+          relatedTo
+        );
+        if (failed.length > 0) {
+          result.relations = { succeeded, failed };
+          printResult({ data: result, warnings }, format);
+          throw new PartialSuccessError(
+            `Issue created but some relations failed`,
+            succeeded,
+            failed
+          );
+        }
+        if (succeeded.length > 0) {
+          result.relations = { succeeded };
+        }
+      }
+      printResult({ data: result }, format);
+    });
+  });
+  issue.command("update").description("Update an existing issue").argument("<id>", "Issue identifier").option("--title <text>", "Issue title").option("--description <text>", "Markdown description").option("--description-file <path>", "Read description from file").option("--assignee <user>", 'Assign to user (pass "null" to clear)').option("--delegate <agent>", 'Delegate to agent (pass "null" to clear)').option("--state <state>", "Workflow state").option("--label <label>", "Add label (repeatable)", collectArray, []).option("--priority <priority>", "Priority level (0-4)").option("--project <project>", "Add to project").option("--parent <id>", 'Set parent issue (pass "null" to clear)').option("--blocks <id>", "This issue blocks <id> (repeatable)", collectArray, []).option("--blocked-by <id>", "This issue is blocked by <id> (repeatable)", collectArray, []).option("--related-to <id>", "Related issue (repeatable)", collectArray, []).option("--due-date <date>", "Due date (ISO format)").option("--estimate <n>", "Effort estimate").action(async (id, opts, cmd) => {
+    const globalOpts = cmd.optsWithGlobals();
+    await runWithClient(globalOpts, async (client, { credentials, agentId, credentialsDir }) => {
+      const format = getFormat(globalOpts.format);
+      const input = {};
+      if (opts.title) {
+        input.title = opts.title;
+      }
+      if (opts.descriptionFile) {
+        input.description = (0, import_fs3.readFileSync)(opts.descriptionFile, "utf-8");
+      } else if (opts.description) {
+        input.description = opts.description;
+      } else if (!process.stdin.isTTY) {
+        try {
+          const stdinContent = (0, import_fs3.readFileSync)(0, "utf-8").trim();
+          if (stdinContent) input.description = stdinContent;
+        } catch (err) {
+          const message = err instanceof Error ? err.message : String(err);
+          console.error(`Error: Failed to read from stdin: ${message}`);
+          process.exit(4);
+        }
+      }
+      if (opts.assignee !== void 0) {
+        if (opts.assignee === "null") {
+          input.assigneeId = null;
+        } else {
+          input.assigneeId = await resolveUser(
+            opts.assignee,
+            credentials,
+            client
+          );
+        }
+      }
+      if (opts.delegate !== void 0) {
+        if (opts.delegate === "null") {
+          input.delegateId = null;
+        } else {
+          input.delegateId = await resolveUser(
+            opts.delegate,
+            credentials,
+            client
+          );
+        }
+      }
+      if (opts.state) {
+        const teamKey = parseTeamKey(id);
+        input.stateId = await resolveState(
+          opts.state,
+          teamKey,
+          client,
+          agentId,
+          credentialsDir
+        );
+      }
+      if (opts.label && opts.label.length > 0) {
+        input.labelIds = await resolveLabels(client, opts.label);
+      }
+      if (opts.priority !== void 0) {
+        input.priority = parseInt(opts.priority, 10);
+      }
+      if (opts.project) {
+        input.projectId = await resolveProject(client, opts.project);
+      }
+      if (opts.parent !== void 0) {
+        if (opts.parent === "null") {
+          input.parentId = null;
+        } else {
+          input.parentId = opts.parent;
+        }
+      }
+      if (opts.dueDate) {
+        input.dueDate = opts.dueDate;
+      }
+      if (opts.estimate !== void 0) {
+        input.estimate = parseInt(opts.estimate, 10);
+      }
+      const payload = await client.updateIssue(id, input);
+      const updated = await payload.issue;
+      const result = {
+        id: updated?.identifier ?? id,
+        title: updated?.title ?? null,
+        url: updated?.url ?? null
+      };
+      const blocks = opts.blocks ?? [];
+      const blockedBy = opts.blockedBy ?? [];
+      const relatedTo = opts.relatedTo ?? [];
+      const hasRelations = blocks.length > 0 || blockedBy.length > 0 || relatedTo.length > 0;
+      if (hasRelations && updated) {
+        const { succeeded, failed, warnings } = await createRelations(
+          client,
+          updated.id,
+          blocks,
+          blockedBy,
+          relatedTo
+        );
+        if (failed.length > 0) {
+          result.relations = { succeeded, failed };
+          printResult({ data: result, warnings }, format);
+          throw new PartialSuccessError(
+            `Issue updated but some relations failed`,
+            succeeded,
+            failed
+          );
+        }
+        if (succeeded.length > 0) {
+          result.relations = { succeeded };
+        }
+      }
+      printResult({ data: result }, format);
+    });
+  });
+  issue.command("transition").description("Move issue to a workflow state by name").argument("<id>", "Issue identifier (e.g., MAIN-42)").argument("<state>", "Target workflow state name").action(async (id, state, _opts, cmd) => {
+    const globalOpts = cmd.optsWithGlobals();
+    await runWithClient(globalOpts, async (client, { agentId, credentialsDir }) => {
+      const format = getFormat(globalOpts.format);
+      const teamKey = parseTeamKey(id);
+      const stateId = await resolveState(
+        state,
+        teamKey,
+        client,
+        agentId,
+        credentialsDir
+      );
+      const payload = await client.updateIssue(id, { stateId });
+      const updated = await payload.issue;
+      printResult(
+        {
+          data: {
+            id: updated?.identifier ?? id,
+            state,
+            url: updated?.url ?? null
+          }
+        },
+        format
+      );
+    });
+  });
+  issue.command("search").description("Full-text search via searchIssues").argument("<query>", "Search query").option("--team <team>", "Boost results for a specific team").option("--include-comments", "Search within comment content").option("--include-archived", "Include archived issues in results").action(async (query, opts, cmd) => {
+    const globalOpts = cmd.optsWithGlobals();
+    await runWithClient(globalOpts, async (client) => {
+      const format = getFormat(globalOpts.format);
+      const searchOpts = {};
+      if (opts.team) {
+        searchOpts.teamId = await resolveTeam(client, opts.team);
+      }
+      if (opts.includeComments) {
+        searchOpts.includeComments = true;
+      }
+      if (opts.includeArchived) {
+        searchOpts.includeArchived = true;
+      }
+      const results = await client.searchIssues(query, searchOpts);
+      const items = results.nodes.map((i) => ({
+        id: i.identifier,
+        title: i.title,
+        url: i.url
+      }));
+      printResult({ data: items }, format);
+    });
+  });
+  issue.command("archive").description("Archive an issue").argument("<id>", "Issue identifier").action(async (id, _opts, cmd) => {
+    const globalOpts = cmd.optsWithGlobals();
+    await runWithClient(globalOpts, async (client) => {
+      const format = getFormat(globalOpts.format);
+      await client.archiveIssue(id);
+      printResult(
+        {
+          data: {
+            id,
+            status: "archived"
+          }
+        },
+        format
+      );
+    });
+  });
+  issue.command("delete").description("Delete an issue").argument("<id>", "Issue identifier").action(async (id, _opts, cmd) => {
+    const globalOpts = cmd.optsWithGlobals();
+    await runWithClient(globalOpts, async (client) => {
+      const format = getFormat(globalOpts.format);
+      await client.deleteIssue(id);
+      printResult(
+        {
+          data: {
+            id,
+            status: "deleted"
+          }
+        },
+        format
+      );
+    });
+  });
+  const schedule = issue.command("schedule").description("Manage recurring issue schedules");
+  schedule.command("create").description("Create a recurring issue schedule").requiredOption("--title <text>", "Issue title").requiredOption("--team <team>", "Team name or ID").requiredOption(
+    "--frequency <freq>",
+    "Recurrence frequency (daily, weekly, monthly, yearly)"
+  ).requiredOption("--start-at <date>", "Start date (ISO format, e.g. 2026-03-01)").option("--interval <n>", "Recurrence interval (default: 1)", "1").option("--description <text>", "Issue description").option("--state <state>", "Initial workflow state").option("--assignee <user>", "Assign to user").option("--priority <n>", "Priority (0-4)").action(async (opts, cmd) => {
+    const globalOpts = cmd.optsWithGlobals();
+    await runWithClient(globalOpts, async (client, { credentials, agentId, credentialsDir }) => {
+      const format = getFormat(globalOpts.format);
+      const scheduleType = FREQUENCY_MAP[opts.frequency];
+      if (!scheduleType) {
+        throw new ValidationError(
+          `Invalid frequency "${opts.frequency}"`,
+          Object.keys(FREQUENCY_MAP)
+        );
+      }
+      const teamId = await resolveTeam(client, opts.team);
+      const interval = parseInt(opts.interval, 10);
+      if (isNaN(interval) || interval < 1) {
+        throw new ValidationError(
+          `Invalid interval "${opts.interval}". Expected a positive integer.`
+        );
+      }
+      const templateData = {
+        title: opts.title,
+        teamId,
+        schedule: {
+          startAt: opts.startAt,
+          interval,
+          type: scheduleType
+        }
+      };
+      if (opts.description) templateData.description = opts.description;
+      if (opts.priority !== void 0) {
+        const priority = parseInt(opts.priority, 10);
+        if (isNaN(priority) || priority < 0 || priority > 4) {
+          throw new ValidationError(
+            `Invalid priority "${opts.priority}". Expected an integer between 0 and 4.`
+          );
+        }
+        templateData.priority = priority;
+      }
+      if (opts.state) {
+        const team = await client.team(teamId);
+        templateData.stateId = await resolveState(
+          opts.state,
+          team.key,
+          client,
+          agentId,
+          credentialsDir
+        );
+      }
+      if (opts.assignee) {
+        templateData.assigneeId = await resolveUser(opts.assignee, credentials, client);
+      }
+      const payload = await client.createTemplate({
+        type: "recurringIssue",
+        name: opts.title,
+        teamId,
+        templateData: JSON.stringify(templateData)
+      });
+      const template = await payload.template;
+      printResult({ data: { id: template.id, name: template.name } }, format);
+    });
+  });
+  schedule.command("list").description("List recurring issue schedules").option("--team <team>", "Filter by team name or ID").action(async (opts, cmd) => {
+    const globalOpts = cmd.optsWithGlobals();
+    await runWithClient(globalOpts, async (client) => {
+      const format = getFormat(globalOpts.format);
+      const teamId = opts.team ? await resolveTeam(client, opts.team) : null;
+      const allTemplates = await client.templates;
+      const filtered = await Promise.all(
+        allTemplates.filter((t) => t.type === "recurringIssue").map(async (t) => {
+          const team = await t.team;
+          return { template: t, teamId: team?.id ?? null };
+        })
+      );
+      const results = filtered.filter(({ teamId: tid }) => teamId === null || tid === teamId).map(({ template: t }) => {
+        const data = typeof t.templateData === "string" ? (() => {
+          try {
+            return JSON.parse(t.templateData);
+          } catch {
+            return {};
+          }
+        })() : t.templateData ?? {};
+        return { id: t.id, name: t.name, schedule: data.schedule ?? null };
+      });
+      printResult({ data: results }, format);
+    });
+  });
+  schedule.command("delete").description("Delete a recurring issue schedule").argument("<id>", "Template UUID").action(async (id, _opts, cmd) => {
+    const globalOpts = cmd.optsWithGlobals();
+    await runWithClient(globalOpts, async (client) => {
+      const format = getFormat(globalOpts.format);
+      await client.deleteTemplate(id);
+      printResult({ data: { id, status: "deleted" } }, format);
+    });
+  });
+}
+
+// src/commands/comment.ts
+var import_fs4 = require("fs");
+function registerCommentCommands(program2) {
+  const comment = program2.command("comment").description("Add and list comments on issues");
+  comment.command("list").description("List all comments on an issue").argument("<issue-id>", "Issue identifier (e.g., MAIN-42)").action(async (issueId, _opts, cmd) => {
+    const globalOpts = cmd.optsWithGlobals();
+    await runWithClient(globalOpts, async (client) => {
+      const issue = await client.issue(issueId);
+      const commentsConnection = await issue.comments();
+      const comments = [];
+      for (const c of commentsConnection.nodes) {
+        const user = await c.user;
+        comments.push({
+          id: c.id,
+          author: user?.name ?? user?.id ?? "Unknown",
+          body: c.body,
+          createdAt: c.createdAt,
+          parentId: c.parentId ?? null
+        });
+      }
+      const format = getFormat(globalOpts.format);
+      printResult({ data: comments }, format);
+    });
+  });
+  comment.command("add").description("Add a comment to an issue").argument("<issue-id>", "Issue identifier (e.g., MAIN-42)").option("--body <text>", "Comment body as markdown").option("--body-file <path>", "Read body from file").option("--reply-to <comment-id>", "Reply to a specific comment").action(async (issueId, opts, cmd) => {
+    const globalOpts = cmd.optsWithGlobals();
+    await runWithClient(globalOpts, async (client) => {
+      let body = opts.body;
+      if (opts.bodyFile) {
+        body = (0, import_fs4.readFileSync)(opts.bodyFile, "utf-8");
+      } else if (!body && !process.stdin.isTTY) {
+        try {
+          const stdinContent = (0, import_fs4.readFileSync)(0, "utf-8").trim();
+          if (stdinContent) body = stdinContent;
+        } catch (err) {
+          const message = err instanceof Error ? err.message : String(err);
+          console.error(`Error: Failed to read from stdin: ${message}`);
+          process.exit(4);
+        }
+      }
+      if (!body) {
+        console.error("Error: --body, --body-file, or stdin pipe is required");
+        process.exit(4);
+      }
+      const input = { issueId, body };
+      if (opts.replyTo) {
+        input.parentId = opts.replyTo;
+      }
+      const result = await client.createComment(input);
+      const commentNode = await result.comment;
+      const format = getFormat(globalOpts.format);
+      printResult(
+        {
+          data: {
+            id: commentNode?.id,
+            issueId,
+            body,
+            parentId: opts.replyTo ?? null,
+            success: result.success
+          }
+        },
+        format
+      );
+    });
+  });
+  comment.command("update").description("Update an existing comment").argument("<comment-id>", "Comment ID").option("--body <text>", "Updated comment body").option("--body-file <path>", "Read body from file").action(async (commentId, opts, cmd) => {
+    const globalOpts = cmd.optsWithGlobals();
+    await runWithClient(globalOpts, async (client) => {
+      let body = opts.body;
+      if (opts.bodyFile) {
+        body = (0, import_fs4.readFileSync)(opts.bodyFile, "utf-8");
+      } else if (!body && !process.stdin.isTTY) {
+        try {
+          const stdinContent = (0, import_fs4.readFileSync)(0, "utf-8").trim();
+          if (stdinContent) body = stdinContent;
+        } catch (err) {
+          const message = err instanceof Error ? err.message : String(err);
+          console.error(`Error: Failed to read from stdin: ${message}`);
+          process.exit(4);
+        }
+      }
+      if (!body) {
+        console.error("Error: --body, --body-file, or stdin pipe is required");
+        process.exit(4);
+      }
+      const result = await client.updateComment(commentId, { body });
+      const format = getFormat(globalOpts.format);
+      printResult(
+        {
+          data: {
+            id: commentId,
+            body,
+            success: result.success
+          }
+        },
+        format
+      );
+    });
+  });
+}
+
+// src/commands/inbox.ts
+var VALID_CATEGORIES = [
+  "assignments",
+  "mentions",
+  "statusChanges",
+  "commentsAndReplies",
+  "reactions",
+  "reviews",
+  "appsAndIntegrations",
+  "triage",
+  "system"
+];
+function parseSinceDate(since) {
+  const durationMatch = since.match(
+    /^-?P(?:(\d+)D)?(?:T(?:(\d+)H)?(?:(\d+)M)?(?:(\d+)S)?)?$/i
+  );
+  if (durationMatch) {
+    const days = parseInt(durationMatch[1] ?? "0", 10);
+    const hours = parseInt(durationMatch[2] ?? "0", 10);
+    const minutes = parseInt(durationMatch[3] ?? "0", 10);
+    const seconds = parseInt(durationMatch[4] ?? "0", 10);
+    const ms = (days * 86400 + hours * 3600 + minutes * 60 + seconds) * 1e3;
+    return new Date(Date.now() - ms);
+  }
+  const date = new Date(since);
+  if (isNaN(date.getTime())) {
+    throw new Error(`Invalid date or duration: ${since}`);
+  }
+  return date;
+}
+function registerInboxCommands(program2) {
+  const inbox = program2.command("inbox").description("View and manage inbox notifications");
+  inbox.command("list", { isDefault: true }).description("List notifications").option("--include-archived", "Show all notifications (not just unprocessed)").option("--type <type>", "Filter by notification type string").option("--category <category>", "Filter by notification category").option("--since <date>", "Only notifications after this date or duration").action(async (opts, cmd) => {
+    const globalOpts = cmd.optsWithGlobals();
+    if (opts.category && !VALID_CATEGORIES.includes(opts.category)) {
+      console.error(
+        `Error: Invalid category "${opts.category}". Valid categories: ${VALID_CATEGORIES.join(", ")}`
+      );
+      process.exit(4);
+    }
+    await runWithClient(globalOpts, async (client) => {
+      const filter = {};
+      if (opts.type) {
+        filter.type = { eq: opts.type };
+      }
+      const notificationsConnection = await client.notifications({
+        filter: Object.keys(filter).length > 0 ? filter : void 0
+      });
+      let notifications = notificationsConnection.nodes;
+      if (!opts.includeArchived) {
+        notifications = notifications.filter(
+          (n) => !n.archivedAt
+        );
+      }
+      if (opts.category) {
+        notifications = notifications.filter(
+          (n) => n.category === opts.category
+        );
+      }
+      if (opts.since) {
+        const sinceDate = parseSinceDate(opts.since);
+        notifications = notifications.filter(
+          (n) => new Date(n.createdAt) >= sinceDate
+        );
+      }
+      const results = [];
+      for (const n of notifications) {
+        const issue = await n.issue;
+        results.push({
+          id: n.id,
+          type: n.type,
+          createdAt: n.createdAt,
+          archivedAt: n.archivedAt ?? null,
+          issue: issue ? { id: issue.id, identifier: issue.identifier, title: issue.title, url: issue.url } : null
+        });
+      }
+      const format = getFormat(globalOpts.format);
+      printResult({ data: results }, format);
+    });
+  });
+  inbox.command("dismiss").description("Dismiss (archive) a notification").argument("<id>", "Notification ID").action(async (id, _opts, cmd) => {
+    const globalOpts = cmd.optsWithGlobals();
+    await runWithClient(globalOpts, async (client) => {
+      const result = await client.archiveNotification(id);
+      const format = getFormat(globalOpts.format);
+      printResult(
+        {
+          data: {
+            id,
+            status: "dismissed",
+            success: result.success
+          }
+        },
+        format
+      );
+    });
+  });
+  inbox.command("dismiss-all").description("Dismiss all unprocessed notifications").action(async (_opts, cmd) => {
+    const globalOpts = cmd.optsWithGlobals();
+    await runWithClient(globalOpts, async (client) => {
+      const notificationsConnection = await client.notifications();
+      const unarchived = notificationsConnection.nodes.filter(
+        (n) => !n.archivedAt
+      );
+      let dismissed = 0;
+      for (const n of unarchived) {
+        await client.archiveNotification(n.id);
+        dismissed++;
+      }
+      const format = getFormat(globalOpts.format);
+      printResult(
+        {
+          data: {
+            status: "dismissed-all",
+            count: dismissed
+          }
+        },
+        format
+      );
+    });
+  });
+}
+
+// src/commands/delegate.ts
+function registerDelegateCommands(program2) {
+  const delegate = program2.command("delegate").description("Delegation shortcuts for assigning agents to issues");
+  delegate.command("assign").description("Delegate an issue to an agent").argument("<issue-id>", "Issue identifier (e.g., TEAM-123)").requiredOption("--to <agent>", "Agent name, email, ID, or 'me'").action(async (issueId, opts, cmd) => {
+    const globalOpts = cmd.optsWithGlobals();
+    await runWithClient(globalOpts, async (client, { credentials }) => {
+      const delegateId = await resolveUser(opts.to, credentials, client);
+      await client.updateIssue(issueId, { delegateId });
+      const format = getFormat(globalOpts.format);
+      printResult(
+        { data: { status: "delegated", issueId, delegateId } },
+        format
+      );
+    });
+  });
+  delegate.command("list").description("List issues delegated to this agent").action(async (_opts, cmd) => {
+    const globalOpts = cmd.optsWithGlobals();
+    await runWithClient(globalOpts, async (client, { credentials }) => {
+      const result = await client.issues({
+        filter: { delegate: { id: { eq: credentials.actorId } } }
+      });
+      const issueData = await Promise.all(
+        result.nodes.map(async (issue) => {
+          const state = await issue.state;
+          const assignee = await issue.assignee;
+          return {
+            id: issue.identifier,
+            title: issue.title,
+            state: state?.name ?? null,
+            assignee: assignee?.name ?? null,
+            priority: issue.priority
+          };
+        })
+      );
+      const format = getFormat(globalOpts.format);
+      printResult({ data: issueData }, format);
+    });
+  });
+  delegate.command("remove").description("Remove delegation from an issue").argument("<issue-id>", "Issue identifier (e.g., TEAM-123)").action(async (issueId, _opts, cmd) => {
+    const globalOpts = cmd.optsWithGlobals();
+    await runWithClient(globalOpts, async (client) => {
+      await client.updateIssue(issueId, { delegateId: null });
+      const format = getFormat(globalOpts.format);
+      printResult(
+        { data: { status: "delegation_removed", issueId } },
+        format
+      );
+    });
+  });
+}
+
+// src/commands/label.ts
+function registerLabelCommands(program2) {
+  const label = program2.command("label").description("Manage labels");
+  label.command("list").description("List all labels in the workspace").option("--team <team>", "Filter by team name or ID").action(async (opts, cmd) => {
+    const globalOpts = cmd.optsWithGlobals();
+    await runWithClient(globalOpts, async (client) => {
+      const filter = {};
+      if (opts.team) {
+        filter.team = { name: { eqIgnoreCase: opts.team } };
+      }
+      const result = await client.issueLabels({
+        filter: Object.keys(filter).length > 0 ? filter : void 0
+      });
+      const labels = await Promise.all(
+        result.nodes.map(async (l) => {
+          const team = await l.team;
+          return {
+            id: l.id,
+            name: l.name,
+            color: l.color,
+            team: team?.name ?? null
+          };
+        })
+      );
+      const format = getFormat(globalOpts.format);
+      printResult({ data: labels }, format);
+    });
+  });
+  label.command("create").description("Create a new label").requiredOption("--name <text>", "Label name").option("--color <hex>", "Label color as hex").option("--team <team>", "Team for team-scoped label").action(async (opts, cmd) => {
+    const globalOpts = cmd.optsWithGlobals();
+    await runWithClient(globalOpts, async (client) => {
+      const input = { name: opts.name };
+      if (opts.color) input.color = opts.color;
+      if (opts.team) {
+        const teams = await client.teams({
+          filter: { name: { eqIgnoreCase: opts.team } }
+        });
+        const team = teams.nodes[0];
+        if (!team) {
+          console.error(`Error: Team "${opts.team}" not found`);
+          process.exit(4);
+        }
+        input.teamId = team.id;
+      }
+      const result = await client.createIssueLabel(input);
+      const created = await result.issueLabel;
+      const format = getFormat(globalOpts.format);
+      printResult(
+        {
+          data: {
+            id: created?.id,
+            name: created?.name,
+            color: created?.color
+          }
+        },
+        format
+      );
+    });
+  });
+}
+
+// src/commands/user.ts
+function registerUserCommands(program2) {
+  const user = program2.command("user").description("User and agent discovery");
+  user.command("list").description("List all users and agents in the workspace").option("--type <type>", "Filter by entity type (user, app, bot)").option("--team <team>", "Filter by team membership").action(async (opts, cmd) => {
+    const globalOpts = cmd.optsWithGlobals();
+    await runWithClient(globalOpts, async (client) => {
+      let users;
+      if (opts.team) {
+        const teams = await client.teams({
+          filter: { name: { eqIgnoreCase: opts.team } }
+        });
+        const team = teams.nodes[0];
+        if (!team) {
+          console.error(`Error: Team "${opts.team}" not found`);
+          process.exit(4);
+        }
+        const members = await team.members();
+        users = members.nodes;
+      } else {
+        const result = await client.users();
+        users = result.nodes;
+      }
+      let userData = users.map((u) => ({
+        id: u.id,
+        name: u.name,
+        displayName: u.displayName,
+        email: u.email ?? null,
+        isMe: u.isMe ?? null,
+        active: u.active
+      }));
+      if (opts.type) {
+        const type = opts.type.toLowerCase();
+        userData = userData.filter((u) => {
+          if (type === "app" || type === "bot") return !u.email;
+          if (type === "user") return !!u.email;
+          return true;
+        });
+      }
+      const format = getFormat(globalOpts.format);
+      printResult({ data: userData }, format);
+    });
+  });
+  user.command("search").description("Search users/agents by name or email").argument("<query>", "Search query").action(async (query, _opts, cmd) => {
+    const globalOpts = cmd.optsWithGlobals();
+    await runWithClient(globalOpts, async (client) => {
+      const result = await client.users();
+      const queryLower = query.toLowerCase();
+      const matches = result.nodes.filter(
+        (u) => u.name?.toLowerCase().includes(queryLower) || u.email?.toLowerCase().includes(queryLower) || u.displayName?.toLowerCase().includes(queryLower)
+      );
+      const userData = matches.map((u) => ({
+        id: u.id,
+        name: u.name,
+        displayName: u.displayName,
+        email: u.email ?? null
+      }));
+      const format = getFormat(globalOpts.format);
+      printResult({ data: userData }, format);
+    });
+  });
+  user.command("me").description("Show this agent's identity").action(async (_opts, cmd) => {
+    const globalOpts = cmd.optsWithGlobals();
+    const agent = globalOpts.agent;
+    if (!agent) {
+      console.error("Error: --agent is required (or set LINEAR_AGENT_ID env var)");
+      process.exit(4);
+    }
+    const credentialsDir = getCredentialsDir(globalOpts);
+    const credentials = readCredentials(agent, credentialsDir);
+    const format = getFormat(globalOpts.format);
+    printResult(
+      {
+        data: {
+          agent,
+          actorId: credentials.actorId,
+          workspace: credentials.workspaceSlug,
+          authMethod: credentials.authMethod,
+          tokenExpiresAt: credentials.tokenExpiresAt
+        }
+      },
+      format
+    );
+  });
+}
+
+// src/commands/team.ts
+function registerTeamCommands(program2) {
+  const team = program2.command("team").description("Team queries");
+  team.command("list").description("List all teams").action(async (_opts, cmd) => {
+    const globalOpts = cmd.optsWithGlobals();
+    await runWithClient(globalOpts, async (client) => {
+      const result = await client.teams();
+      const teams = result.nodes.map((t) => ({
+        id: t.id,
+        key: t.key,
+        name: t.name,
+        description: t.description ?? null
+      }));
+      const format = getFormat(globalOpts.format);
+      printResult({ data: teams }, format);
+    });
+  });
+  team.command("members").description("List members of a team").argument("<team>", "Team name or key").action(async (teamName, _opts, cmd) => {
+    const globalOpts = cmd.optsWithGlobals();
+    await runWithClient(globalOpts, async (client) => {
+      const teams = await client.teams({
+        filter: { name: { eqIgnoreCase: teamName } }
+      });
+      let team2 = teams.nodes[0];
+      if (!team2) {
+        const byKey = await client.teams({
+          filter: { key: { eq: teamName.toUpperCase() } }
+        });
+        team2 = byKey.nodes[0];
+      }
+      if (!team2) {
+        console.error(`Error: Team "${teamName}" not found`);
+        process.exit(4);
+      }
+      const members = await team2.members();
+      const memberData = members.nodes.map((m) => ({
+        id: m.id,
+        name: m.name,
+        displayName: m.displayName,
+        email: m.email ?? null,
+        active: m.active
+      }));
+      const format = getFormat(globalOpts.format);
+      printResult({ data: memberData }, format);
+    });
+  });
+}
+
+// src/commands/project.ts
+var import_fs5 = require("fs");
+async function resolveTeamId(client, team) {
+  if (/^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i.test(team)) {
+    return team;
+  }
+  const teams = await client.teams({
+    filter: { name: { eqIgnoreCase: team } }
+  });
+  const match = teams.nodes[0];
+  if (!match) {
+    console.error(`Error: Team "${team}" not found`);
+    process.exit(4);
+  }
+  return match.id;
+}
+function registerProjectCommands(program2) {
+  const project = program2.command("project").description("Project queries");
+  project.command("create").description("Create a new project").requiredOption("--name <text>", "Project name").requiredOption("--team <team>", "Associate project with team (name or ID)").option("--description <text>", "Project description (markdown, 255-char limit)").option("--description-file <path>", "Read description from file").option("--content <text>", "Project overview content (long-form markdown)").option("--content-file <path>", "Read project overview content from file").option("--start-date <date>", "Start date (YYYY-MM-DD)").option("--target-date <date>", "Target date (YYYY-MM-DD)").option("--lead <user>", "Project lead (name or email)").option("--priority <n>", "Priority (0=none, 1=urgent, 2=high, 3=normal, 4=low)").action(async (opts, cmd) => {
+    const globalOpts = cmd.optsWithGlobals();
+    await runWithClient(globalOpts, async (client, { credentials }) => {
+      const input = {
+        name: opts.name,
+        teamIds: [await resolveTeamId(client, opts.team)]
+      };
+      if (opts.descriptionFile) {
+        input.description = (0, import_fs5.readFileSync)(opts.descriptionFile, "utf-8");
+      } else if (opts.description) {
+        input.description = opts.description;
+      }
+      if (opts.contentFile) {
+        input.content = (0, import_fs5.readFileSync)(opts.contentFile, "utf-8");
+      } else if (opts.content) {
+        input.content = opts.content;
+      }
+      if (opts.startDate) {
+        input.startDate = opts.startDate;
+      }
+      if (opts.targetDate) {
+        input.targetDate = opts.targetDate;
+      }
+      if (opts.lead) {
+        input.leadId = await resolveUser(opts.lead, credentials, client);
+      }
+      if (opts.priority !== void 0) {
+        const priority = parseInt(opts.priority, 10);
+        if (isNaN(priority) || priority < 0 || priority > 4) {
+          console.error(`Invalid value for --priority: "${opts.priority}". Expected an integer between 0 and 4.`);
+          process.exit(1);
+        }
+        input.priority = priority;
+      }
+      const payload = await client.createProject(input);
+      const created = await payload.project;
+      const format = getFormat(globalOpts.format);
+      printResult(
+        {
+          data: {
+            id: created?.id ?? null,
+            name: created?.name ?? opts.name,
+            url: created?.url ?? null,
+            success: payload.success
+          }
+        },
+        format
+      );
+    });
+  });
+  project.command("list").description("List projects").option("--team <team>", "Filter by team").action(async (opts, cmd) => {
+    const globalOpts = cmd.optsWithGlobals();
+    await runWithClient(globalOpts, async (client) => {
+      const filter = {};
+      if (opts.team) {
+        filter.accessibleTeams = { name: { eqIgnoreCase: opts.team } };
+      }
+      const result = await client.projects({
+        filter: Object.keys(filter).length > 0 ? filter : void 0
+      });
+      const projects = result.nodes.map((p) => ({
+        id: p.id,
+        name: p.name,
+        state: p.state,
+        progress: p.progress,
+        startDate: p.startDate ?? null,
+        targetDate: p.targetDate ?? null
+      }));
+      const format = getFormat(globalOpts.format);
+      printResult({ data: projects }, format);
+    });
+  });
+  project.command("get").description("Get project details").argument("<id>", "Project ID").action(async (id, _opts, cmd) => {
+    const globalOpts = cmd.optsWithGlobals();
+    await runWithClient(globalOpts, async (client) => {
+      const p = await client.project(id);
+      const format = getFormat(globalOpts.format);
+      printResult(
+        {
+          data: {
+            id: p.id,
+            name: p.name,
+            description: p.description ?? null,
+            content: p.content ?? null,
+            state: p.state,
+            progress: p.progress,
+            startDate: p.startDate ?? null,
+            targetDate: p.targetDate ?? null
+          }
+        },
+        format
+      );
+    });
+  });
+  project.command("update").description("Update project metadata").argument("<id>", "Project ID").option("--name <text>", "New project name").option("--description <text>", "Project description (markdown, 255-char limit)").option("--description-file <path>", "Read description from file").option("--content <text>", "Project overview content (long-form markdown)").option("--content-file <path>", "Read project overview content from file").option("--start-date <date>", 'Start date (YYYY-MM-DD, or "null" to clear)').option("--target-date <date>", 'Target date (YYYY-MM-DD, or "null" to clear)').option("--lead <user>", 'Project lead (name, email, or "null" to clear)').option("--priority <n>", "Priority (0=none, 1=urgent, 2=high, 3=normal, 4=low)").action(async (id, opts, cmd) => {
+    const globalOpts = cmd.optsWithGlobals();
+    await runWithClient(globalOpts, async (client, { credentials }) => {
+      const input = {};
+      if (opts.name) {
+        input.name = opts.name;
+      }
+      if (opts.descriptionFile) {
+        input.description = (0, import_fs5.readFileSync)(opts.descriptionFile, "utf-8");
+      } else if (opts.description) {
+        input.description = opts.description;
+      }
+      if (opts.contentFile) {
+        input.content = (0, import_fs5.readFileSync)(opts.contentFile, "utf-8");
+      } else if (opts.content) {
+        input.content = opts.content;
+      }
+      if (opts.startDate !== void 0) {
+        input.startDate = opts.startDate === "null" ? null : opts.startDate;
+      }
+      if (opts.targetDate !== void 0) {
+        input.targetDate = opts.targetDate === "null" ? null : opts.targetDate;
+      }
+      if (opts.lead !== void 0) {
+        if (opts.lead === "null") {
+          input.leadId = null;
+        } else {
+          input.leadId = await resolveUser(opts.lead, credentials, client);
+        }
+      }
+      if (opts.priority !== void 0) {
+        const priority = parseInt(opts.priority, 10);
+        if (isNaN(priority) || priority < 0 || priority > 4) {
+          console.error(`Invalid value for --priority: "${opts.priority}". Expected an integer between 0 and 4.`);
+          process.exit(1);
+        }
+        input.priority = priority;
+      }
+      const payload = await client.updateProject(id, input);
+      const updated = await payload.project;
+      const format = getFormat(globalOpts.format);
+      printResult(
+        {
+          data: {
+            id: updated?.id ?? id,
+            name: updated?.name ?? null,
+            url: updated?.url ?? null,
+            success: payload.success
+          }
+        },
+        format
+      );
+    });
+  });
+}
+
+// src/commands/attachment.ts
+var import_fs6 = require("fs");
+var import_path3 = require("path");
+var CONTENT_TYPES = {
+  ".png": "image/png",
+  ".jpg": "image/jpeg",
+  ".jpeg": "image/jpeg",
+  ".gif": "image/gif",
+  ".webp": "image/webp",
+  ".svg": "image/svg+xml",
+  ".pdf": "application/pdf",
+  ".txt": "text/plain",
+  ".md": "text/markdown",
+  ".json": "application/json",
+  ".csv": "text/csv",
+  ".zip": "application/zip"
+};
+function registerAttachmentCommands(program2) {
+  const attachment = program2.command("attachment").description("Manage issue attachments");
+  attachment.command("add").description("Add an attachment to an issue (idempotent per URL)").argument("<issue-id>", "Issue identifier (e.g., TEAM-123)").requiredOption("--url <url>", "URL to attach").option("--title <text>", "Display title for the link").action(async (issueId, opts, cmd) => {
+    const globalOpts = cmd.optsWithGlobals();
+    await runWithClient(globalOpts, async (client) => {
+      const input = {
+        issueId,
+        url: opts.url
+      };
+      if (opts.title) input.title = opts.title;
+      const result = await client.createAttachment(input);
+      const created = await result.attachment;
+      const format = getFormat(globalOpts.format);
+      printResult(
+        {
+          data: {
+            id: created?.id,
+            url: opts.url,
+            title: opts.title ?? null,
+            issueId
+          }
+        },
+        format
+      );
+    });
+  });
+  attachment.command("list").description("List attachments on an issue").argument("<issue-id>", "Issue identifier (e.g., TEAM-123)").action(async (issueId, _opts, cmd) => {
+    const globalOpts = cmd.optsWithGlobals();
+    await runWithClient(globalOpts, async (client) => {
+      const issue = await client.issue(issueId);
+      const attachments = await issue.attachments();
+      const attachmentData = attachments.nodes.map((a) => ({
+        id: a.id,
+        url: a.url,
+        title: a.title ?? null
+      }));
+      const format = getFormat(globalOpts.format);
+      printResult({ data: attachmentData }, format);
+    });
+  });
+  attachment.command("remove").description("Remove an attachment").argument("<attachment-id>", "Attachment ID").action(async (attachmentId, _opts, cmd) => {
+    const globalOpts = cmd.optsWithGlobals();
+    await runWithClient(globalOpts, async (client) => {
+      await client.deleteAttachment(attachmentId);
+      const format = getFormat(globalOpts.format);
+      printResult(
+        { data: { status: "removed", attachmentId } },
+        format
+      );
+    });
+  });
+  attachment.command("upload").description("Upload a local file and attach it to an issue or project").argument("<file-path>", "Path to the local file to upload").option("--issue <id>", "Issue identifier to attach the file to (e.g., TEAM-123)").option("--project <id>", "Project name or ID to upload the file for").option("--title <text>", "Display title for the attachment (defaults to filename)").action(async (filePath, opts, cmd) => {
+    const globalOpts = cmd.optsWithGlobals();
+    await runWithClient(globalOpts, async (client) => {
+      if (!opts.issue && !opts.project) {
+        console.error("Error: --issue or --project is required");
+        process.exit(4);
+      }
+      const resolvedPath = (0, import_path3.resolve)(filePath);
+      let stat;
+      try {
+        stat = (0, import_fs6.statSync)(resolvedPath);
+      } catch {
+        console.error(`Error: file not found: ${filePath}`);
+        process.exit(4);
+      }
+      if (!stat.isFile()) {
+        console.error(`Error: ${filePath} is not a file`);
+        process.exit(4);
+      }
+      const filename = (0, import_path3.basename)(resolvedPath);
+      const ext = (0, import_path3.extname)(filename).toLowerCase();
+      const contentType = CONTENT_TYPES[ext] ?? "application/octet-stream";
+      const size = stat.size;
+      const uploadPayload = await client.fileUpload(contentType, filename, size);
+      const uploadFile = uploadPayload.uploadFile;
+      if (!uploadFile) {
+        throw new Error("Failed to get upload URL from Linear");
+      }
+      let fileContent;
+      try {
+        fileContent = (0, import_fs6.readFileSync)(resolvedPath);
+      } catch {
+        console.error(`Error: could not read file: ${filePath}`);
+        process.exit(4);
+      }
+      const headers = {
+        "Content-Type": contentType,
+        "Cache-Control": "public, max-age=31536000"
+      };
+      for (const h of uploadFile.headers) {
+        headers[h.key] = h.value;
+      }
+      const uploadResponse = await fetch(uploadFile.uploadUrl, {
+        method: "PUT",
+        headers,
+        body: fileContent
+      });
+      if (!uploadResponse.ok) {
+        throw new Error(
+          `Upload failed: ${uploadResponse.status} ${uploadResponse.statusText}`
+        );
+      }
+      const title = opts.title ?? filename;
+      const format = getFormat(globalOpts.format);
+      if (opts.issue) {
+        const result = await client.createAttachment({
+          issueId: opts.issue,
+          url: uploadFile.assetUrl,
+          title
+        });
+        const created = await result.attachment;
+        printResult(
+          {
+            data: {
+              id: created?.id,
+              url: uploadFile.assetUrl,
+              title,
+              issueId: opts.issue
+            }
+          },
+          format
+        );
+      } else {
+        printResult(
+          {
+            data: {
+              url: uploadFile.assetUrl,
+              title,
+              projectId: opts.project
+            }
+          },
+          format
+        );
+      }
+    });
+  });
+}
+
+// src/commands/state.ts
+function registerStateCommands(program2) {
+  const state = program2.command("state").description("Workflow state queries");
+  state.command("list").description("List workflow states").option("--team <team>", "Filter by team name or key").action(async (opts, cmd) => {
+    const globalOpts = cmd.optsWithGlobals();
+    await runWithClient(globalOpts, async (client, { agentId, credentialsDir }) => {
+      let cache = readCache(agentId, credentialsDir);
+      if (opts.team) {
+        const teams = await client.teams({
+          filter: { name: { eqIgnoreCase: opts.team } }
+        });
+        let team = teams.nodes[0];
+        if (!team) {
+          const byKey = await client.teams({
+            filter: { key: { eq: opts.team.toUpperCase() } }
+          });
+          team = byKey.nodes[0];
+        }
+        if (!team) {
+          console.error(`Error: Team "${opts.team}" not found`);
+          process.exit(4);
+        }
+        const states = await team.states();
+        const stateData = states.nodes.map((s) => ({
+          id: s.id,
+          name: s.name,
+          type: s.type,
+          color: s.color,
+          position: s.position,
+          team: team.name
+        }));
+        const stateMap = {};
+        for (const s of states.nodes) {
+          stateMap[s.name] = s.id;
+        }
+        cache = setTeamStates(cache, team.key, stateMap);
+        writeCache(agentId, credentialsDir, cache);
+        const format = getFormat(globalOpts.format);
+        printResult({ data: stateData }, format);
+      } else {
+        const teamsResult = await client.teams();
+        const allStates = [];
+        for (const t of teamsResult.nodes) {
+          const states = await t.states();
+          const stateMap = {};
+          for (const s of states.nodes) {
+            stateMap[s.name] = s.id;
+            allStates.push({
+              id: s.id,
+              name: s.name,
+              type: s.type,
+              color: s.color,
+              position: s.position,
+              team: t.name
+            });
+          }
+          cache = setTeamStates(cache, t.key, stateMap);
+        }
+        writeCache(agentId, credentialsDir, cache);
+        const format = getFormat(globalOpts.format);
+        printResult({ data: allStates }, format);
+      }
+    });
+  });
+}
+
+// src/cli.ts
+var pkg = JSON.parse(
+  (0, import_fs7.readFileSync)((0, import_path4.join)(__dirname, "..", "package.json"), "utf-8")
+);
+var program = new import_commander.Command();
+program.name("linear").description("CLI tool for AI agents to interact with Linear").version(pkg.version).option("--agent <id>", "agent identifier (env: LINEAR_AGENT_ID)", process.env.LINEAR_AGENT_ID).option(
+  "--credentials-dir <path>",
+  "path to credentials directory (env: LINEAR_AGENT_CREDENTIALS_DIR)",
+  process.env.LINEAR_AGENT_CREDENTIALS_DIR ?? "~/.linear/credentials/"
+).addOption(
+  new import_commander.Option("--format <format>", "output format (default: auto-detect TTY)").choices(["json", "text"])
+);
+registerAuthCommands(program);
+registerIssueCommands(program);
+registerCommentCommands(program);
+registerInboxCommands(program);
+registerDelegateCommands(program);
+registerLabelCommands(program);
+registerUserCommands(program);
+registerTeamCommands(program);
+registerProjectCommands(program);
+registerAttachmentCommands(program);
+registerStateCommands(program);
+program.parseAsync(process.argv).catch((err) => {
+  if (err instanceof CLIError) {
+    console.error(`Error: ${err.message}`);
+    if (err.resolution) console.error(err.resolution);
+    process.exit(err.exitCode);
+  }
+  console.error(`Error: ${err?.message ?? String(err)}`);
+  process.exit(1);
+});