@enrichlayer/el-linear 1.5.0 → 1.7.0

package/README.md

@@ -74,13 +74,41 @@ every team ends up writing themselves:
 
 ## Authentication
 
-The API token is resolved in this order:
+el-linear supports either OAuth or a personal Linear API token. OAuth is
+configured with:
+
+```bash
+el-linear init oauth
+```
+
+By default, that command walks you through registering your own Linear OAuth
+app. Teams can make the flow a single browser authorization step by writing a
+local, untracked app-defaults file at `~/.config/el-linear/team-oauth.json`
+or pointing `EL_LINEAR_OAUTH_CONFIG` at one:
+
+```json
+{
+  "linearOAuth": {
+    "clientId": "your-linear-oauth-client-id",
+    "redirectPort": 8765,
+    "scopes": ["read", "write", "issues:create", "comments:create"],
+    "passwordManagerPath": "op://vault/item/client_id"
+  }
+}
+```
+
+`passwordManagerPath` is optional metadata for humans/scripts; el-linear does
+not execute password-manager commands from it. Do not put a `client_secret` in
+this shared file. The OAuth flow uses PKCE.
+
+At runtime, credentials are resolved in this order:
 
 1. `--api-token <token>` flag.
 2. `LINEAR_API_TOKEN` environment variable.
-3. **Active profile's** `~/.config/el-linear/profiles/<name>/token` file (see *Profiles* below).
-4. `~/.config/el-linear/token` file (legacy single-profile, recommended for human use when only one workspace is needed).
-5. `~/.linear_api_token` file (legacy, still honored).
+3. **Active profile's** OAuth state (`oauth.json`) from `el-linear init oauth`.
+4. **Active profile's** `~/.config/el-linear/profiles/<name>/token` file (see *Profiles* below).
+5. `~/.config/el-linear/token` file (legacy single-profile, recommended for human use when only one workspace is needed).
+6. `~/.linear_api_token` file (legacy, still honored).
 
 el-linear never logs the token.
 

package/dist/auth/oauth-app-config.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Optional local OAuth app defaults.
+ *
+ * This deliberately lives outside the packaged/default config. Teams can
+ * materialize it from a password manager, while the OSS CLI keeps requiring
+ * users to bring their own OAuth app when no local file exists.
+ */
+import { type OAuthScope } from "./oauth-client.js";
+export declare const TEAM_OAUTH_CONFIG_ENV = "EL_LINEAR_OAUTH_CONFIG";
+export interface TeamOAuthConfig {
+    clientId: string;
+    redirectPort: number;
+    scopes: OAuthScope[];
+    /**
+     * Optional human-facing pointer such as `op://vault/item/client_id`.
+     * The CLI does not execute password-manager commands from this value.
+     */
+    passwordManagerPath?: string;
+    sourcePath: string;
+}
+export declare function readTeamOAuthConfig(env?: NodeJS.ProcessEnv): Promise<TeamOAuthConfig | null>;

package/dist/auth/oauth-app-config.js

@@ -0,0 +1,82 @@
+/**
+ * Optional local OAuth app defaults.
+ *
+ * This deliberately lives outside the packaged/default config. Teams can
+ * materialize it from a password manager, while the OSS CLI keeps requiring
+ * users to bring their own OAuth app when no local file exists.
+ */
+import fs from "node:fs/promises";
+import { TEAM_OAUTH_CONFIG_PATH } from "../config/paths.js";
+import { DEFAULT_SCOPES, validateScopes, } from "./oauth-client.js";
+export const TEAM_OAUTH_CONFIG_ENV = "EL_LINEAR_OAUTH_CONFIG";
+export async function readTeamOAuthConfig(env = process.env) {
+    const envPath = env[TEAM_OAUTH_CONFIG_ENV]?.trim();
+    const sourcePath = envPath || TEAM_OAUTH_CONFIG_PATH;
+    let raw;
+    try {
+        raw = await fs.readFile(sourcePath, "utf8");
+    }
+    catch (err) {
+        if (err.code === "ENOENT" && !envPath) {
+            return null;
+        }
+        if (err.code === "ENOENT") {
+            throw new Error(`${TEAM_OAUTH_CONFIG_ENV} points to ${sourcePath}, but that file does not exist.`);
+        }
+        throw err;
+    }
+    let parsed;
+    try {
+        parsed = JSON.parse(raw);
+    }
+    catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        throw new Error(`Failed to parse ${sourcePath}: ${message}`);
+    }
+    const linearOAuth = parsed.linearOAuth;
+    if (!linearOAuth || typeof linearOAuth !== "object") {
+        throw new Error(`${sourcePath} must contain a linearOAuth object with a clientId.`);
+    }
+    const clientId = typeof linearOAuth.clientId === "string" ? linearOAuth.clientId.trim() : "";
+    if (!clientId) {
+        throw new Error(`${sourcePath} linearOAuth.clientId must be a string.`);
+    }
+    const redirectPort = parseRedirectPort(linearOAuth.redirectPort, sourcePath);
+    const scopes = parseScopes(linearOAuth.scopes, sourcePath);
+    const passwordManagerPath = parsePasswordManagerPath(linearOAuth.passwordManagerPath, sourcePath);
+    return {
+        clientId,
+        redirectPort,
+        scopes,
+        passwordManagerPath,
+        sourcePath,
+    };
+}
+function parseRedirectPort(value, sourcePath) {
+    if (value === undefined)
+        return 8765;
+    if (typeof value !== "number" ||
+        !Number.isInteger(value) ||
+        value < 1024 ||
+        value > 65535) {
+        throw new Error(`${sourcePath} linearOAuth.redirectPort must be an integer between 1024 and 65535.`);
+    }
+    return value;
+}
+function parseScopes(value, sourcePath) {
+    if (value === undefined)
+        return [...DEFAULT_SCOPES];
+    if (!Array.isArray(value) || !value.every((s) => typeof s === "string")) {
+        throw new Error(`${sourcePath} linearOAuth.scopes must be a string array.`);
+    }
+    return validateScopes(value);
+}
+function parsePasswordManagerPath(value, sourcePath) {
+    if (value === undefined)
+        return undefined;
+    if (typeof value !== "string") {
+        throw new Error(`${sourcePath} linearOAuth.passwordManagerPath must be a string when set.`);
+    }
+    const trimmed = value.trim();
+    return trimmed || undefined;
+}

package/dist/commands/attachments.js

@@ -1,8 +1,8 @@
-import { getApiToken } from "../utils/auth.js";
-import { FileService } from "../utils/file-service.js";
+import { createFileService } from "../utils/file-service.js";
 import { createGraphQLAttachmentsService } from "../utils/graphql-attachments-service.js";
 import { createLinearService } from "../utils/linear-service.js";
 import { handleAsyncCommand, outputSuccess } from "../utils/output.js";
+import { getRootOpts } from "../utils/root-opts.js";
 export function setupAttachmentsCommands(program) {
     const attachments = program
         .command("attachments")
@@ -14,16 +14,15 @@ export function setupAttachmentsCommands(program) {
         .requiredOption("--file <path>", "path to file to upload")
         .option("--title <title>", "attachment title (defaults to filename)")
         .action(handleAsyncCommand(async (issueId, options, command) => {
-        const rootOpts = command.parent.parent.opts();
-        const apiToken = getApiToken(rootOpts);
-        const linearService = createLinearService(rootOpts);
+        const rootOpts = getRootOpts(command);
+        const linearService = await createLinearService(rootOpts);
         const resolvedIssueId = await linearService.resolveIssueId(issueId);
-        const fileService = new FileService(apiToken);
+        const fileService = await createFileService(rootOpts);
         const uploadResult = await fileService.uploadFile(options.file);
         if (!uploadResult.success) {
             throw new Error(uploadResult.error);
         }
-        const attachmentsService = createGraphQLAttachmentsService(rootOpts);
+        const attachmentsService = await createGraphQLAttachmentsService(rootOpts);
         const attachment = await attachmentsService.createAttachment({
             issueId: resolvedIssueId,
             url: uploadResult.assetUrl,
@@ -36,10 +35,10 @@ export function setupAttachmentsCommands(program) {
         .description("List attachments on an issue.")
         .option("-l, --limit <number>", "maximum number of attachments", "50")
         .action(handleAsyncCommand(async (issueId, options, command) => {
-        const rootOpts = command.parent.parent.opts();
-        const linearService = createLinearService(rootOpts);
+        const rootOpts = getRootOpts(command);
+        const linearService = await createLinearService(rootOpts);
         const resolvedIssueId = await linearService.resolveIssueId(issueId);
-        const attachmentsService = createGraphQLAttachmentsService(rootOpts);
+        const attachmentsService = await createGraphQLAttachmentsService(rootOpts);
         const allAttachments = await attachmentsService.listAttachments(resolvedIssueId);
         const limit = Number.parseInt(options.limit, 10);
         const data = allAttachments.slice(0, limit);
@@ -49,8 +48,8 @@ export function setupAttachmentsCommands(program) {
         .command("delete <attachmentId>")
         .description("Delete an attachment.")
         .action(handleAsyncCommand(async (attachmentId, _options, command) => {
-        const rootOpts = command.parent.parent.opts();
-        const attachmentsService = createGraphQLAttachmentsService(rootOpts);
+        const rootOpts = getRootOpts(command);
+        const attachmentsService = await createGraphQLAttachmentsService(rootOpts);
         await attachmentsService.deleteAttachment(attachmentId);
         outputSuccess({ success: true, message: "Attachment deleted" });
     }));

package/dist/commands/batch.js

@@ -4,6 +4,7 @@ import { createGraphQLService } from "../utils/graphql-service.js";
 import { createLinearService } from "../utils/linear-service.js";
 import { logger } from "../utils/logger.js";
 import { handleAsyncCommand, outputSuccess, outputWarning, } from "../utils/output.js";
+import { getRootOpts } from "../utils/root-opts.js";
 import { splitList } from "../utils/validators.js";
 /**
  * Parse the --filter string into structured search arguments.
@@ -29,8 +30,8 @@ function parseFilterString(filter) {
  * Returns LinearIssue[] so we can show a preview.
  */
 async function resolveTargetIssues(options, rootOpts) {
-    const graphQLService = createGraphQLService(rootOpts);
-    const linearService = createLinearService(rootOpts);
+    const graphQLService = await createGraphQLService(rootOpts);
+    const linearService = await createLinearService(rootOpts);
     const issuesService = new GraphQLIssuesService(graphQLService, linearService);
     if (options.issues) {
         const ids = splitList(options.issues);
@@ -95,7 +96,7 @@ async function executeBatch(issues, operation) {
     return { results };
 }
 async function handleBatchAssign(options, command) {
-    const rootOpts = command.parent.parent.opts();
+    const rootOpts = getRootOpts(command);
     if (!options.assignee) {
         throw new Error("--assignee is required.");
     }
@@ -116,8 +117,8 @@ async function handleBatchAssign(options, command) {
         });
         return;
     }
-    const graphQLService = createGraphQLService(rootOpts);
-    const linearService = createLinearService(rootOpts);
+    const graphQLService = await createGraphQLService(rootOpts);
+    const linearService = await createLinearService(rootOpts);
     const issuesService = new GraphQLIssuesService(graphQLService, linearService);
     const { results } = await executeBatch(issues, (issue) => issuesService.updateIssue({ id: issue.identifier, assigneeId }, "adding"));
     outputSuccess({
@@ -132,7 +133,7 @@ async function handleBatchAssign(options, command) {
     });
 }
 async function handleBatchLabel(options, command) {
-    const rootOpts = command.parent.parent.opts();
+    const rootOpts = getRootOpts(command);
     if (!(options.add || options.remove)) {
         throw new Error("Specify --add and/or --remove for labels.");
     }
@@ -163,8 +164,8 @@ async function handleBatchLabel(options, command) {
         });
         return;
     }
-    const graphQLService = createGraphQLService(rootOpts);
-    const linearService = createLinearService(rootOpts);
+    const graphQLService = await createGraphQLService(rootOpts);
+    const linearService = await createLinearService(rootOpts);
     const issuesService = new GraphQLIssuesService(graphQLService, linearService);
     const removeLower = removeLabels.map((l) => l.toLowerCase());
     const { results } = await executeBatch(issues, (issue) => {
@@ -197,7 +198,7 @@ async function handleBatchLabel(options, command) {
     });
 }
 async function handleBatchMove(options, command) {
-    const rootOpts = command.parent.parent.opts();
+    const rootOpts = getRootOpts(command);
     if (!options.project) {
         throw new Error("--project is required.");
     }
@@ -217,8 +218,8 @@ async function handleBatchMove(options, command) {
         });
         return;
     }
-    const graphQLService = createGraphQLService(rootOpts);
-    const linearService = createLinearService(rootOpts);
+    const graphQLService = await createGraphQLService(rootOpts);
+    const linearService = await createLinearService(rootOpts);
     const issuesService = new GraphQLIssuesService(graphQLService, linearService);
     const { results } = await executeBatch(issues, (issue) => issuesService.updateIssue({ id: issue.identifier, projectId: options.project }, "adding"));
     outputSuccess({
@@ -233,7 +234,7 @@ async function handleBatchMove(options, command) {
     });
 }
 async function handleBatchStatus(options, command) {
-    const rootOpts = command.parent.parent.opts();
+    const rootOpts = getRootOpts(command);
     if (!options.status) {
         throw new Error("--status is required.");
     }
@@ -253,8 +254,8 @@ async function handleBatchStatus(options, command) {
         });
         return;
     }
-    const graphQLService = createGraphQLService(rootOpts);
-    const linearService = createLinearService(rootOpts);
+    const graphQLService = await createGraphQLService(rootOpts);
+    const linearService = await createLinearService(rootOpts);
     const issuesService = new GraphQLIssuesService(graphQLService, linearService);
     const { results } = await executeBatch(issues, (issue) => issuesService.updateIssue({ id: issue.identifier, statusId: options.status }, "adding"));
     outputSuccess({

package/dist/commands/comments.js

@@ -2,12 +2,14 @@ import { readFileSync } from "node:fs";
 import { resolveUserDisplayName } from "../config/resolver.js";
 import { CREATE_COMMENT_MUTATION, LIST_COMMENTS_QUERY, UPDATE_COMMENT_MUTATION, } from "../queries/comments.js";
 import { autoLinkReferences, } from "../utils/auto-link-references.js";
+import { applyFooter } from "../utils/footer.js";
 import { createGraphQLService, } from "../utils/graphql-service.js";
 import { extractIssueReferences } from "../utils/issue-reference-extractor.js";
 import { wrapIssueReferencesAsLinks } from "../utils/issue-reference-wrapper.js";
 import { createLinearService, } from "../utils/linear-service.js";
 import { resolveMentions } from "../utils/mention-resolver.js";
 import { handleAsyncCommand, outputSuccess } from "../utils/output.js";
+import { getRootOpts } from "../utils/root-opts.js";
 import { validateReferences } from "../utils/validate-references.js";
 import { getWorkspaceUrlKey } from "../utils/workspace-url.js";
 // Match Linear's bodyData validation error in multiple phrasings so a wording
@@ -98,10 +100,18 @@ async function autoLinkCommentReferences(args) {
     return result;
 }
 async function handleCreateComment(issueId, options, command) {
-    const rootOpts = command.parent.parent.opts();
-    const graphQLService = createGraphQLService(rootOpts);
-    const linearService = createLinearService(rootOpts);
-    const rawBody = readBody(options);
+    const rootOpts = getRootOpts(command);
+    const graphQLService = await createGraphQLService(rootOpts);
+    const linearService = await createLinearService(rootOpts);
+    // Apply messageFooter (config or --footer flag) before any further
+    // processing, so auto-link / mention-resolution see it as part of the body.
+    // Commander parses --no-footer as `options.footer === false`.
+    const noFooter = options.footer === false;
+    const explicitFooter = typeof options.footer === "string" ? options.footer : undefined;
+    const rawBody = applyFooter(readBody(options), {
+        footer: explicitFooter,
+        noFooter,
+    }) ?? "";
     const resolvedIssueId = await linearService.resolveIssueId(issueId);
     // Wrap valid refs as markdown links before mention resolution. Idempotent against
     // already-wrapped refs.
@@ -171,9 +181,9 @@ async function handleCreateComment(issueId, options, command) {
     outputSuccess(autoLinked ? { ...output, autoLinked } : output);
 }
 async function handleUpdateComment(commentId, options, command) {
-    const rootOpts = command.parent.parent.opts();
-    const graphQLService = createGraphQLService(rootOpts);
-    const linearService = createLinearService(rootOpts);
+    const rootOpts = getRootOpts(command);
+    const graphQLService = await createGraphQLService(rootOpts);
+    const linearService = await createLinearService(rootOpts);
     const rawBody = readBody(options);
     const { body, preResolved } = await prepareCommentBodyWithLinks(rawBody, options, linearService, graphQLService);
     const autoMention = options.autoMention !== false;
@@ -218,9 +228,9 @@ async function handleUpdateComment(commentId, options, command) {
     outputSuccess(autoLinked ? { ...output, autoLinked } : output);
 }
 async function handleListComments(issueId, options, command) {
-    const rootOpts = command.parent.parent.opts();
-    const graphQLService = createGraphQLService(rootOpts);
-    const linearService = createLinearService(rootOpts);
+    const rootOpts = getRootOpts(command);
+    const graphQLService = await createGraphQLService(rootOpts);
+    const linearService = await createLinearService(rootOpts);
     const resolvedId = await linearService.resolveIssueId(issueId);
     const result = await graphQLService.rawRequest(LIST_COMMENTS_QUERY, {
         issueId: resolvedId,
@@ -254,6 +264,8 @@ export function setupCommentsCommands(program) {
         .option("--file <path>", "read comment body from file")
         .option("--no-auto-mention", "do not auto-convert bare team-member names to @mentions")
         .option("--no-auto-link", "skip wrapping issue refs as markdown links and creating sidebar relations")
+        .option("--footer <text>", "text appended to the comment body (overrides config.messageFooter)")
+        .option("--no-footer", "skip the configured messageFooter for this comment")
         .action(handleAsyncCommand(handleCreateComment));
     comments
         .command("update <commentId>")

package/dist/commands/cycles.js

@@ -2,6 +2,7 @@ import { resolveTeam } from "../config/resolver.js";
 import { invalidParameterError, notFoundError, requiresParameterError, } from "../utils/error-messages.js";
 import { createLinearService } from "../utils/linear-service.js";
 import { handleAsyncCommand, outputSuccess } from "../utils/output.js";
+import { getRootOpts } from "../utils/root-opts.js";
 export function setupCyclesCommands(program) {
     const cycles = program
         .command("cycles")
@@ -19,9 +20,9 @@ export function setupCyclesCommands(program) {
         if (options.aroundActive && !options.team) {
             throw requiresParameterError("--around-active", "--team");
         }
-        const rootOpts = command.parent.parent.opts();
+        const rootOpts = getRootOpts(command);
         const teamFilter = options.team ? resolveTeam(options.team) : undefined;
-        const linearService = createLinearService(rootOpts);
+        const linearService = await createLinearService(rootOpts);
         const allCycles = await linearService.getCycles(teamFilter, options.active || undefined, Number.parseInt(options.limit, 10));
         if (options.aroundActive) {
             const n = Number.parseInt(options.aroundActive, 10);
@@ -51,11 +52,11 @@ export function setupCyclesCommands(program) {
         .option("--team <team>", "team key, name, or ID to scope name lookup")
         .option("--issues-first <n>", "how many issues to fetch (default 50)", "50")
         .action(handleAsyncCommand(async (cycleIdOrName, options, command) => {
-        const rootOpts = command.parent.parent.opts();
+        const rootOpts = getRootOpts(command);
         const teamFilter = options.team
             ? resolveTeam(options.team)
             : undefined;
-        const linearService = createLinearService(rootOpts);
+        const linearService = await createLinearService(rootOpts);
         const cycleId = await linearService.resolveCycleId(cycleIdOrName, teamFilter);
         const cycle = await linearService.getCycleById(cycleId, Number.parseInt(options.issuesFirst || "50", 10));
         outputSuccess(cycle);

package/dist/commands/documents.js

@@ -2,6 +2,7 @@ import { createGraphQLAttachmentsService } from "../utils/graphql-attachments-se
 import { createGraphQLDocumentsService } from "../utils/graphql-documents-service.js";
 import { createLinearService } from "../utils/linear-service.js";
 import { handleAsyncCommand, outputSuccess } from "../utils/output.js";
+import { getRootOpts } from "../utils/root-opts.js";
 function extractDocumentIdFromUrl(url) {
     try {
         const parsed = new URL(url);
@@ -25,9 +26,9 @@ function extractDocumentIdFromUrl(url) {
     }
 }
 async function handleCreateDocument(options, command) {
-    const rootOpts = command.parent.parent.opts();
-    const documentsService = createGraphQLDocumentsService(rootOpts);
-    const linearService = createLinearService(rootOpts);
+    const rootOpts = getRootOpts(command);
+    const documentsService = await createGraphQLDocumentsService(rootOpts);
+    const linearService = await createLinearService(rootOpts);
     const document = await documentsService.createDocument({
         title: options.title,
         content: options.content,
@@ -44,7 +45,7 @@ async function handleCreateDocument(options, command) {
         color: options.color,
     });
     if (options.attachTo) {
-        const attachmentsService = createGraphQLAttachmentsService(rootOpts);
+        const attachmentsService = await createGraphQLAttachmentsService(rootOpts);
         const issueId = await linearService.resolveIssueId(options.attachTo);
         try {
             await attachmentsService.createAttachment({
@@ -66,15 +67,15 @@ async function handleListDocuments(options, command) {
     if (options.project && options.issue) {
         throw new Error("Cannot use --project and --issue together. Choose one filter.");
     }
-    const rootOpts = command.parent.parent.opts();
-    const documentsService = createGraphQLDocumentsService(rootOpts);
-    const linearService = createLinearService(rootOpts);
+    const rootOpts = getRootOpts(command);
+    const documentsService = await createGraphQLDocumentsService(rootOpts);
+    const linearService = await createLinearService(rootOpts);
     const limit = Number.parseInt(options.limit || "50", 10);
     if (Number.isNaN(limit) || limit < 1) {
         throw new Error(`Invalid limit "${options.limit}": must be a positive number`);
     }
     if (options.issue) {
-        const attachmentsService = createGraphQLAttachmentsService(rootOpts);
+        const attachmentsService = await createGraphQLAttachmentsService(rootOpts);
         const issueId = await linearService.resolveIssueId(options.issue);
         const attachments = await attachmentsService.listAttachments(issueId);
         const documentSlugIds = [
@@ -129,9 +130,9 @@ export function setupDocumentsCommands(program) {
         .option("--icon <icon>", "document icon")
         .option("--color <color>", "icon color")
         .action(handleAsyncCommand(async (documentId, options, command) => {
-        const rootOpts = command.parent.parent.opts();
-        const documentsService = createGraphQLDocumentsService(rootOpts);
-        const linearService = createLinearService(rootOpts);
+        const rootOpts = getRootOpts(command);
+        const documentsService = await createGraphQLDocumentsService(rootOpts);
+        const linearService = await createLinearService(rootOpts);
         const input = {};
         if (options.title) {
             input.title = options.title;
@@ -154,8 +155,9 @@ export function setupDocumentsCommands(program) {
         .command("read <documentId>")
         .description("Read a document")
         .action(handleAsyncCommand(async (documentId, _options, command) => {
-        const rootOpts = command.parent.parent.opts();
-        outputSuccess(await createGraphQLDocumentsService(rootOpts).getDocument(documentId));
+        const rootOpts = getRootOpts(command);
+        const documentsService = await createGraphQLDocumentsService(rootOpts);
+        outputSuccess(await documentsService.getDocument(documentId));
     }));
     documents
         .command("list")
@@ -168,8 +170,9 @@ export function setupDocumentsCommands(program) {
         .command("delete <documentId>")
         .description("Delete (trash) a document")
         .action(handleAsyncCommand(async (documentId, _options, command) => {
-        const rootOpts = command.parent.parent.opts();
-        await createGraphQLDocumentsService(rootOpts).deleteDocument(documentId);
+        const rootOpts = getRootOpts(command);
+        const documentsService = await createGraphQLDocumentsService(rootOpts);
+        await documentsService.deleteDocument(documentId);
         outputSuccess({ success: true, message: "Document moved to trash" });
     }));
 }

package/dist/commands/embeds.js

@@ -1,6 +1,6 @@
-import { getApiToken } from "../utils/auth.js";
-import { FileService } from "../utils/file-service.js";
+import { createFileService } from "../utils/file-service.js";
 import { handleAsyncCommand, outputSuccess } from "../utils/output.js";
+import { getRootOpts } from "../utils/root-opts.js";
 export function setupEmbedsCommands(program) {
     const embeds = program
         .command("embeds")
@@ -12,8 +12,7 @@ export function setupEmbedsCommands(program) {
         .option("--output <path>", "output file path")
         .option("--overwrite", "overwrite existing file", false)
         .action(handleAsyncCommand(async (url, options, command) => {
-        const apiToken = getApiToken(command.parent.parent.opts());
-        const fileService = new FileService(apiToken);
+        const fileService = await createFileService(getRootOpts(command));
         const result = await fileService.downloadFile(url, {
             output: options.output,
             overwrite: options.overwrite,
@@ -40,8 +39,7 @@ export function setupEmbedsCommands(program) {
         .command("upload <file>")
         .description("Upload a file to Linear storage.")
         .action(handleAsyncCommand(async (filePath, _options, command) => {
-        const apiToken = getApiToken(command.parent.parent.opts());
-        const fileService = new FileService(apiToken);
+        const fileService = await createFileService(getRootOpts(command));
         const result = await fileService.uploadFile(filePath);
         if (result.success) {
             outputSuccess({

package/dist/commands/graphql.js

@@ -2,6 +2,7 @@ import fs from "node:fs";
 import { INTROSPECT_ROOT_QUERY, INTROSPECT_TYPE_QUERY, } from "../queries/introspect.js";
 import { createGraphQLService } from "../utils/graphql-service.js";
 import { handleAsyncCommand, outputSuccess } from "../utils/output.js";
+import { getRootOpts } from "../utils/root-opts.js";
 async function executeQuery(query, options, command) {
     let finalQuery = query;
     if (options.file) {
@@ -22,8 +23,8 @@ async function executeQuery(query, options, command) {
             throw new Error(`Invalid JSON in --variables: ${options.variables}`);
         }
     }
-    const rootOpts = command.parent.opts();
-    const graphQLService = createGraphQLService(rootOpts);
+    const rootOpts = getRootOpts(command);
+    const graphQLService = await createGraphQLService(rootOpts);
     const result = await graphQLService.rawRequest(finalQuery, variables);
     outputSuccess(result);
 }
@@ -41,8 +42,8 @@ export function setupGraphQLCommands(program) {
         .description("Introspect the Linear GraphQL schema. Without args lists root query fields; with a type name shows its fields and args.")
         .option("--filter <pattern>", "filter fields by name (case-insensitive substring match)")
         .action(handleAsyncCommand(async (typeName, options, command) => {
-        const rootOpts = command.parent.opts();
-        const graphQLService = createGraphQLService(rootOpts);
+        const rootOpts = getRootOpts(command);
+        const graphQLService = await createGraphQLService(rootOpts);
         if (typeName) {
             const result = await graphQLService.rawRequest(INTROSPECT_TYPE_QUERY, { typeName });
             const typeInfo = result.__type;

package/dist/commands/init/aliases.js

@@ -159,13 +159,11 @@ export async function runAliasesStep(token, existing, options = {}) {
             default: false,
         });
     if (!proceed) {
-        // biome-ignore lint/suspicious/noConsole: wizard
         console.log("  Skipped — run `el-linear init aliases` to add or edit aliases later.");
         return new Map();
     }
     const allUsers = await fetchAllUsers(token);
     if (allUsers.length === 0) {
-        // biome-ignore lint/suspicious/noConsole: wizard
         console.log("  No active users visible to this token.");
         return new Map();
     }
@@ -176,25 +174,20 @@ export async function runAliasesStep(token, existing, options = {}) {
     const collisions = findDisplayNameCollisions(allUsers);
     const collidingIds = new Set();
     if (collisions.size > 0) {
-        // biome-ignore lint/suspicious/noConsole: wizard
         console.log(`  ⚠ ${collisions.size} display name(s) are shared by multiple active users — skipping those to avoid alias corruption:`);
         for (const [name, group] of collisions) {
-            // biome-ignore lint/suspicious/noConsole: wizard
             console.log(`    "${name}" — ${group.map((u) => u.email ?? u.id).join(", ")}`);
             for (const u of group)
                 collidingIds.add(u.id);
         }
-        // biome-ignore lint/suspicious/noConsole: wizard
         console.log("    (Add aliases manually in ~/.config/el-linear/config.json for now; schema migration in 1.3.0.)");
     }
     const users = allUsers.filter((u) => !collidingIds.has(u.id));
     if (users.length === 0) {
-        // biome-ignore lint/suspicious/noConsole: wizard
         console.log("  No safe-to-alias users remain after collision filter.");
         return new Map();
     }
     const startIdx = await resolveResumePoint(users);
-    // biome-ignore lint/suspicious/noConsole: wizard
     console.log(`  Walking ${users.length - startIdx}/${users.length} users. Type 'q' at any prompt to stop and save progress.`);
     const updates = new Map();
     let lastCompletedIdx = startIdx - 1;
@@ -213,7 +206,6 @@ export async function runAliasesStep(token, existing, options = {}) {
             const update = await promptForUser(i + 1, users.length, u, existing);
             if (update === "quit") {
                 await saveProgress();
-                // biome-ignore lint/suspicious/noConsole: wizard
                 console.log(`  Saved progress at ${lastCompletedIdx + 1}/${users.length}. Resume with \`el-linear init aliases\`.`);
                 return updates;
             }
@@ -225,7 +217,6 @@ export async function runAliasesStep(token, existing, options = {}) {
             lastCompletedIdx = i;
         }
         await clearAliasesProgress();
-        // biome-ignore lint/suspicious/noConsole: wizard
         console.log(`  ✓ Walked all ${users.length} users.`);
         return updates;
     }
@@ -253,7 +244,6 @@ async function resolveResumePoint(users) {
         return 0;
     const idx = users.findIndex((u) => u.id === progress.lastCompletedUserId);
     if (idx < 0) {
-        // biome-ignore lint/suspicious/noConsole: wizard
         console.log("  Saved progress points at a user no longer in the workspace. Starting over.");
         await clearAliasesProgress();
         return 0;
@@ -272,18 +262,14 @@ async function promptForUser(index, total, user, existing) {
     const currentAliases = currentAliasesFor(existing, fullName);
     const currentGithub = currentHandleFor(existing, "github", fullName);
     const currentGitlab = currentHandleFor(existing, "gitlab", fullName);
-    // biome-ignore lint/suspicious/noConsole: wizard
     console.log(`\n  [${index}/${total}] ${fullName}${user.email ? ` <${user.email}>` : ""}`);
     if (currentAliases.length > 0) {
-        // biome-ignore lint/suspicious/noConsole: wizard
         console.log(`    Current aliases: ${currentAliases.join(", ")}`);
     }
     if (currentGithub) {
-        // biome-ignore lint/suspicious/noConsole: wizard
         console.log(`    Current GitHub:  ${currentGithub}`);
     }
     if (currentGitlab) {
-        // biome-ignore lint/suspicious/noConsole: wizard
         console.log(`    Current GitLab:  ${currentGitlab}`);
     }
     const action = await select({