@enrichlayer/el-linear 1.4.0 → 1.6.0

package/dist/commands/labels.js

@@ -3,11 +3,12 @@ import { CREATE_LABEL_MUTATION, FIND_PARENT_LABEL_QUERY, RESTORE_LABEL_MUTATION,
 import { createGraphQLService } from "../utils/graphql-service.js";
 import { createLinearService } from "../utils/linear-service.js";
 import { handleAsyncCommand, outputSuccess } from "../utils/output.js";
+import { getRootOpts } from "../utils/root-opts.js";
 import { validateHexColor } from "../utils/validators.js";
 async function handleCreateLabel(name, options, command) {
-    const rootOpts = command.parent.parent.opts();
+    const rootOpts = getRootOpts(command);
     const teamId = resolveTeam(options.team);
-    const graphQLService = createGraphQLService(rootOpts);
+    const graphQLService = await createGraphQLService(rootOpts);
     const input = { name, teamId };
     if (options.color) {
         input.color = validateHexColor(options.color);
@@ -37,8 +38,8 @@ async function handleCreateLabel(name, options, command) {
     outputSuccess(createResult.issueLabel);
 }
 async function handleRetireLabel(labelId, _options, command) {
-    const rootOpts = command.parent.parent.opts();
-    const graphQLService = createGraphQLService(rootOpts);
+    const rootOpts = getRootOpts(command);
+    const graphQLService = await createGraphQLService(rootOpts);
     const result = await graphQLService.rawRequest(RETIRE_LABEL_MUTATION, {
         id: labelId,
     });
@@ -49,8 +50,8 @@ async function handleRetireLabel(labelId, _options, command) {
     outputSuccess(retireResult.issueLabel);
 }
 async function handleRestoreLabel(labelId, _options, command) {
-    const rootOpts = command.parent.parent.opts();
-    const graphQLService = createGraphQLService(rootOpts);
+    const rootOpts = getRootOpts(command);
+    const graphQLService = await createGraphQLService(rootOpts);
     const result = await graphQLService.rawRequest(RESTORE_LABEL_MUTATION, {
         id: labelId,
     });
@@ -72,9 +73,9 @@ export function setupLabelsCommands(program) {
         .option("--team <team>", "filter by team key, name, or ID")
         .option("-l, --limit <number>", "limit results", "100")
         .action(handleAsyncCommand(async (options, command) => {
-        const rootOpts = command.parent.parent.opts();
+        const rootOpts = getRootOpts(command);
         const teamFilter = options.team ? resolveTeam(options.team) : undefined;
-        const service = createLinearService(rootOpts);
+        const service = await createLinearService(rootOpts);
         const result = await service.getLabels(teamFilter, Number.parseInt(options.limit, 10));
         outputSuccess({
             data: result.labels,

package/dist/commands/profile/migrate-legacy.d.ts

@@ -0,0 +1,96 @@
+/**
+ * `el-linear profile migrate-legacy` — one-shot migration from the legacy
+ * single-file config layout (`~/.config/el-linear/{token,config.json}`) to
+ * the named-profiles layout introduced in 1.4 (`~/.config/el-linear/
+ * profiles/<name>/{token,config.json}`).
+ *
+ * Why this command exists:
+ *
+ *   When a user upgraded el-linear to >=1.4, their existing single-file
+ *   `config.json` was preserved verbatim, but the legacy `token` slot was
+ *   sometimes cleared (depending on how the upgrade was performed) and
+ *   1.4 expects per-profile tokens. Result: every command failed with
+ *   "Authentication required" while the rich legacy config (member
+ *   aliases, brand rules, default labels) sat right there on disk with
+ *   no documented migration path.
+ *
+ * Design constraints:
+ *
+ * - **Each step is independently idempotent.** Re-running the command
+ *   after a successful migration is a no-op — config + token files match,
+ *   active-profile already points at the right name. Re-running after a
+ *   partial failure picks up where it left off without `--force`.
+ *
+ * - **Validate before writing.** A token that doesn't pass `viewer { ... }`
+ *   never lands on disk. The validate-then-write order means an interrupted
+ *   migration can't leave a dud token in a freshly-created profile dir.
+ *
+ * - **Legacy preservation.** We never delete the legacy `config.json` or
+ *   `token` — the user gets a rollback path. A one-line stdout hint says
+ *   so explicitly.
+ *
+ * - **`--force` is opt-in destruction.** When the destination profile
+ *   already has a config.json or token that *differs* from the source,
+ *   the command refuses by default with a clear diff hint. `--force`
+ *   overwrites; `--yes` skips the interactive confirm. Both are
+ *   required-together for unattended (CI / scripted) overwrites.
+ */
+import { confirm, input, password } from "@inquirer/prompts";
+import type { Command } from "commander";
+import { CONFIG_PATH, PROFILES_DIR, TOKEN_PATH } from "../../config/paths.js";
+export interface MigrateLegacyOptions {
+    /** Target profile name. Defaults to "default" when omitted. */
+    name?: string;
+    /** Path to a file containing the API token (whitespace trimmed). */
+    tokenFrom?: string;
+    /** Overwrite existing profile config.json/token even if they differ. */
+    force?: boolean;
+    /** Skip interactive confirmation when --force is needed. */
+    yes?: boolean;
+    /** Skip the interactive name prompt — use whatever `name` resolved to. */
+    skipPrompt?: boolean;
+}
+export interface MigrateLegacyDeps {
+    /**
+     * Hook around the `viewer` validation call so tests can short-circuit
+     * the GraphQL roundtrip. Production wiring uses the real
+     * `validateToken` from `init/token.ts`.
+     */
+    validateToken?: (token: string) => Promise<{
+        id: string;
+        organization: {
+            urlKey: string;
+            name: string;
+        };
+        displayName: string;
+        email: string;
+    }>;
+    /** stdout writer (for the success line + "kept for rollback" hint). */
+    stdout?: {
+        write: (chunk: string) => void;
+    };
+    /**
+     * Inquirer-based prompts. Tests inject deterministic responses so we
+     * don't need a TTY.
+     */
+    prompts?: {
+        input: typeof input;
+        password: typeof password;
+        confirm: typeof confirm;
+    };
+}
+/** Register `el-linear profile migrate-legacy` under the parent `profile` command. */
+export declare function registerMigrateLegacy(profile: Command): void;
+/**
+ * Top-level orchestrator. Each helper below is independently idempotent;
+ * this function just sequences them and prints the final ✓ banner.
+ *
+ * Exit semantics:
+ *
+ *   - Missing legacy config → `process.exit(1)` (user error, nothing to do).
+ *   - Refused overwrite (no --force) → throws — handled by handleAsyncCommand
+ *     elsewhere in the CLI and surfaces as a structured JSON error on stdout.
+ *   - Token validation failure → throws (no on-disk change has happened yet).
+ */
+export declare function runMigrateLegacy(options: MigrateLegacyOptions, deps?: MigrateLegacyDeps): Promise<void>;
+export { CONFIG_PATH, PROFILES_DIR, TOKEN_PATH };

package/dist/commands/profile/migrate-legacy.js

@@ -0,0 +1,271 @@
+/**
+ * `el-linear profile migrate-legacy` — one-shot migration from the legacy
+ * single-file config layout (`~/.config/el-linear/{token,config.json}`) to
+ * the named-profiles layout introduced in 1.4 (`~/.config/el-linear/
+ * profiles/<name>/{token,config.json}`).
+ *
+ * Why this command exists:
+ *
+ *   When a user upgraded el-linear to >=1.4, their existing single-file
+ *   `config.json` was preserved verbatim, but the legacy `token` slot was
+ *   sometimes cleared (depending on how the upgrade was performed) and
+ *   1.4 expects per-profile tokens. Result: every command failed with
+ *   "Authentication required" while the rich legacy config (member
+ *   aliases, brand rules, default labels) sat right there on disk with
+ *   no documented migration path.
+ *
+ * Design constraints:
+ *
+ * - **Each step is independently idempotent.** Re-running the command
+ *   after a successful migration is a no-op — config + token files match,
+ *   active-profile already points at the right name. Re-running after a
+ *   partial failure picks up where it left off without `--force`.
+ *
+ * - **Validate before writing.** A token that doesn't pass `viewer { ... }`
+ *   never lands on disk. The validate-then-write order means an interrupted
+ *   migration can't leave a dud token in a freshly-created profile dir.
+ *
+ * - **Legacy preservation.** We never delete the legacy `config.json` or
+ *   `token` — the user gets a rollback path. A one-line stdout hint says
+ *   so explicitly.
+ *
+ * - **`--force` is opt-in destruction.** When the destination profile
+ *   already has a config.json or token that *differs* from the source,
+ *   the command refuses by default with a clear diff hint. `--force`
+ *   overwrites; `--yes` skips the interactive confirm. Both are
+ *   required-together for unattended (CI / scripted) overwrites.
+ */
+import { promises as fsp } from "node:fs";
+import path from "node:path";
+import { confirm, input, password } from "@inquirer/prompts";
+import { ACTIVE_PROFILE_FILE, CONFIG_DIR, CONFIG_PATH, PROFILES_DIR, profilePaths, TOKEN_PATH, } from "../../config/paths.js";
+import { sanitizeForLog, validateToken } from "../init/token.js";
+const DEFAULT_PROMPTS = { input, password, confirm };
+/** Register `el-linear profile migrate-legacy` under the parent `profile` command. */
+export function registerMigrateLegacy(profile) {
+    profile
+        .command("migrate-legacy")
+        .description("Copy the legacy ~/.config/el-linear/{config.json,token} into a named profile so >=1.4 commands work again.")
+        .option("--name <name>", "Target profile name. Defaults to `default`.", "default")
+        .option("--token-from <path>", "Read the API token from this file instead of prompting.")
+        .option("--force", "Overwrite an existing per-profile config.json or token even when contents differ.")
+        .option("--yes", "Skip interactive confirmations (still respects --force semantics).")
+        .action(async (opts) => {
+        await runMigrateLegacy({
+            name: opts.name,
+            tokenFrom: opts.tokenFrom,
+            force: opts.force === true,
+            yes: opts.yes === true,
+        });
+    });
+}
+/**
+ * Top-level orchestrator. Each helper below is independently idempotent;
+ * this function just sequences them and prints the final ✓ banner.
+ *
+ * Exit semantics:
+ *
+ *   - Missing legacy config → `process.exit(1)` (user error, nothing to do).
+ *   - Refused overwrite (no --force) → throws — handled by handleAsyncCommand
+ *     elsewhere in the CLI and surfaces as a structured JSON error on stdout.
+ *   - Token validation failure → throws (no on-disk change has happened yet).
+ */
+export async function runMigrateLegacy(options, deps = {}) {
+    const stdout = deps.stdout ?? process.stdout;
+    const prompts = deps.prompts ?? DEFAULT_PROMPTS;
+    const validate = deps.validateToken ?? validateToken;
+    // 1. Pre-flight: legacy config must exist. There's nothing to migrate
+    //    on a freshly-onboarded machine and we don't want to silently
+    //    create an empty profile.
+    if (!(await pathExists(CONFIG_PATH))) {
+        stdout.write(`Nothing to migrate — no legacy config found at ${CONFIG_PATH}.\n`);
+        stdout.write("If this is a fresh install, run `el-linear init` instead.\n");
+        process.exit(1);
+    }
+    const initialName = (options.name ?? "default").trim() || "default";
+    let name = initialName;
+    // Allow an interactive override of the target name unless --yes was passed
+    // (scripted) or --name was explicitly set to something other than the
+    // default. Keeps backward compat with the CLI flag while not surprising
+    // CI runs.
+    if (!options.skipPrompt && !options.yes && options.name === undefined) {
+        const answer = await prompts.input({
+            message: "Target profile name:",
+            default: name,
+        });
+        const trimmed = answer.trim();
+        if (trimmed.length > 0)
+            name = trimmed;
+    }
+    if (!isSafeName(name)) {
+        throw new Error(`Invalid profile name "${name}". Allowed: [a-z0-9_.-], up to 64 chars.`);
+    }
+    // 2. Token source priority: --token-from > EL_LINEAR_TOKEN > prompt.
+    //    Validate before writing anything to disk.
+    const token = await resolveAndValidateToken(options, prompts, validate);
+    // 3. Profile dir.
+    const paths = profilePaths(name);
+    const profileDir = path.dirname(paths.configPath);
+    await fsp.mkdir(profileDir, { recursive: true, mode: 0o700 });
+    // 4. Config copy with idempotent + force semantics.
+    await copyConfigIntoProfile(paths.configPath, options, prompts);
+    // 5. Token write with idempotent + force semantics.
+    await writeProfileToken(paths.tokenPath, token, options, prompts);
+    // 6. active-profile marker.
+    await ensureActiveProfile(name);
+    // 7. Legacy preservation hint. We do NOT delete the legacy paths —
+    //    the user gets a rollback if anything went sideways.
+    stdout.write(`legacy ${CONFIG_PATH} kept for rollback; safe to remove later if no longer needed\n`);
+    // 8. Final verify against the freshly-written profile token. This is
+    //    a defensive double-check: the token was already validated above,
+    //    but verifying *after* the write catches any FS-level surprise
+    //    (e.g. wrong token landed in the wrong dir on a multi-profile box).
+    const onDiskToken = (await fsp.readFile(paths.tokenPath, "utf8")).trim();
+    const viewer = await validate(onDiskToken);
+    stdout.write(`✓ Migrated. Active profile: ${name}. Workspace: ${viewer.organization.urlKey}\n`);
+}
+// ---- Helpers --------------------------------------------------------
+async function resolveAndValidateToken(options, prompts, validate) {
+    if (options.tokenFrom) {
+        const raw = await fsp.readFile(options.tokenFrom, "utf8");
+        const token = raw.trim();
+        if (!token) {
+            throw new Error(`Token file ${options.tokenFrom} is empty.`);
+        }
+        await validate(token);
+        return token;
+    }
+    const envToken = process.env.EL_LINEAR_TOKEN?.trim();
+    if (envToken) {
+        await validate(envToken);
+        return envToken;
+    }
+    // Interactive: up to three attempts, hidden input. We re-prompt on
+    // validation failure rather than aborting so the user can paste a
+    // fresh token without re-running the whole command.
+    for (let attempt = 0; attempt < 3; attempt++) {
+        const candidate = (await prompts.password({
+            message: attempt === 0
+                ? "Linear API token (input hidden):"
+                : "Try again (input hidden):",
+            mask: "*",
+            validate: (s) => s.trim().length > 0 || "Token cannot be empty",
+        })).trim();
+        try {
+            await validate(candidate);
+            return candidate;
+        }
+        catch (err) {
+            const raw = err instanceof Error ? err.message : String(err);
+            console.log(`  ✗ ${sanitizeForLog(raw)}`);
+        }
+    }
+    throw new Error("Could not validate a Linear API token after 3 attempts. Aborting migration.");
+}
+async function copyConfigIntoProfile(destConfigPath, options, prompts) {
+    const sourceContent = await fsp.readFile(CONFIG_PATH, "utf8");
+    if (!(await pathExists(destConfigPath))) {
+        await fsp.writeFile(destConfigPath, sourceContent, {
+            mode: 0o644,
+            encoding: "utf8",
+        });
+        return;
+    }
+    const destContent = await fsp.readFile(destConfigPath, "utf8");
+    if (destContent === sourceContent) {
+        // Idempotent re-run — nothing to do.
+        return;
+    }
+    if (!options.force) {
+        throw new Error([
+            `Refusing to overwrite ${destConfigPath} — its contents differ from ${CONFIG_PATH}.`,
+            "Re-run with --force to overwrite. The legacy file is kept either way; only the per-profile copy changes.",
+            `Diff hint: \`diff ${CONFIG_PATH} ${destConfigPath}\``,
+        ].join("\n"));
+    }
+    if (!options.yes) {
+        const ok = await prompts.confirm({
+            message: `Overwrite ${destConfigPath} with the legacy config?`,
+            default: false,
+        });
+        if (!ok) {
+            throw new Error("Aborted by user.");
+        }
+    }
+    await fsp.writeFile(destConfigPath, sourceContent, {
+        mode: 0o644,
+        encoding: "utf8",
+    });
+}
+async function writeProfileToken(destTokenPath, token, options, prompts) {
+    const newline = `${token}\n`;
+    if (!(await pathExists(destTokenPath))) {
+        await fsp.writeFile(destTokenPath, newline, {
+            mode: 0o600,
+            encoding: "utf8",
+        });
+        // fs.writeFile mode is only honored on file creation; chmod defensively
+        // in case a parent process pre-created the file with permissive perms.
+        await fsp.chmod(destTokenPath, 0o600);
+        return;
+    }
+    const existing = (await fsp.readFile(destTokenPath, "utf8")).trim();
+    if (existing === token) {
+        // Idempotent re-run — already correct; force perms regardless.
+        await fsp.chmod(destTokenPath, 0o600);
+        return;
+    }
+    if (!options.force) {
+        throw new Error([
+            `Refusing to overwrite ${destTokenPath} — it contains a different token.`,
+            "Re-run with --force to overwrite the per-profile token.",
+        ].join("\n"));
+    }
+    if (!options.yes) {
+        const ok = await prompts.confirm({
+            message: `Overwrite the existing token at ${destTokenPath}?`,
+            default: false,
+        });
+        if (!ok) {
+            throw new Error("Aborted by user.");
+        }
+    }
+    await fsp.writeFile(destTokenPath, newline, {
+        mode: 0o600,
+        encoding: "utf8",
+    });
+    await fsp.chmod(destTokenPath, 0o600);
+}
+async function ensureActiveProfile(name) {
+    await fsp.mkdir(CONFIG_DIR, { recursive: true, mode: 0o700 });
+    let current = null;
+    if (await pathExists(ACTIVE_PROFILE_FILE)) {
+        current = (await fsp.readFile(ACTIVE_PROFILE_FILE, "utf8")).trim();
+    }
+    if (current === name)
+        return;
+    await fsp.writeFile(ACTIVE_PROFILE_FILE, `${name}\n`, {
+        mode: 0o644,
+        encoding: "utf8",
+    });
+}
+async function pathExists(p) {
+    try {
+        await fsp.access(p);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * Profile names land in filesystem paths and the active-profile marker.
+ * Same conservative charset as `profile add` to avoid `..` traversal,
+ * shell metacharacters, and Unicode lookalikes.
+ */
+function isSafeName(name) {
+    return /^[A-Za-z0-9][A-Za-z0-9_.-]{0,63}$/.test(name);
+}
+// Re-export internals so the integration test (and follow-up commands)
+// can compose them without re-implementing the idempotency rules.
+export { CONFIG_PATH, PROFILES_DIR, TOKEN_PATH };

package/dist/commands/profile.js

@@ -26,6 +26,7 @@ import { confirm } from "@inquirer/prompts";
 import { ACTIVE_PROFILE_FILE, CONFIG_DIR, CONFIG_PATH, PROFILES_DIR, profilePaths, resolveActiveProfile, setActiveProfileForSession, TOKEN_PATH, } from "../config/paths.js";
 import { outputSuccess, outputWarning } from "../utils/output.js";
 import { runFullWizard } from "./init/index.js";
+import { registerMigrateLegacy } from "./profile/migrate-legacy.js";
 export function setupProfileCommands(program) {
     const profile = program
         .command("profile")
@@ -72,6 +73,11 @@ export function setupProfileCommands(program) {
         .action(async (name, opts) => {
         await runProfileRemove(name, opts.force === true);
     });
+    // `el-linear profile migrate-legacy` — registered alongside add/list/etc.
+    // Lives in its own module so the multi-step migration logic stays
+    // self-contained and unit-testable without dragging in the full
+    // profile-management surface.
+    registerMigrateLegacy(profile);
 }
 export async function runProfileList() {
     const active = resolveActiveProfile();

package/dist/commands/project-milestones.js

@@ -3,6 +3,7 @@ import { multipleMatchesError, notFoundError, } from "../utils/error-messages.js
 import { createGraphQLService, } from "../utils/graphql-service.js";
 import { createLinearService, } from "../utils/linear-service.js";
 import { handleAsyncCommand, outputSuccess } from "../utils/output.js";
+import { getRootOpts } from "../utils/root-opts.js";
 import { isUuid } from "../utils/uuid.js";
 import { validateIsoDate } from "../utils/validators.js";
 async function resolveMilestoneId(milestoneNameOrId, graphQLService, linearService, projectNameOrId) {
@@ -37,9 +38,9 @@ async function resolveMilestoneId(milestoneNameOrId, graphQLService, linearServi
     return nodes[0].id;
 }
 async function handleListMilestones(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 projectId = await linearService.resolveProjectId(options.project);
     const result = await graphQLService.rawRequest(LIST_PROJECT_MILESTONES_QUERY, {
         projectId,
@@ -51,9 +52,9 @@ async function handleListMilestones(options, command) {
     outputSuccess({ data: nodes, meta: { count: nodes.length } });
 }
 async function handleReadMilestone(milestoneIdOrName, 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 milestoneId = await resolveMilestoneId(milestoneIdOrName, graphQLService, linearService, options.project);
     const result = await graphQLService.rawRequest(GET_PROJECT_MILESTONE_BY_ID_QUERY, {
         id: milestoneId,
@@ -62,9 +63,9 @@ async function handleReadMilestone(milestoneIdOrName, options, command) {
     outputSuccess(result.projectMilestone);
 }
 async function handleCreateMilestone(name, 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 projectId = await linearService.resolveProjectId(options.project);
     if (options.targetDate) {
         validateIsoDate(options.targetDate);
@@ -82,9 +83,9 @@ async function handleCreateMilestone(name, options, command) {
     outputSuccess(createData.projectMilestone);
 }
 async function handleUpdateMilestone(milestoneIdOrName, 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 milestoneId = await resolveMilestoneId(milestoneIdOrName, graphQLService, linearService, options.project);
     const updateVars = { id: milestoneId };
     if (options.name !== undefined) {

package/dist/commands/projects.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 } from "../utils/output.js";
+import { getRootOpts } from "../utils/root-opts.js";
 import { isUuid } from "../utils/uuid.js";
 import { splitList } from "../utils/validators.js";
 function formatProjectsOutput(projects, format, fieldNames) {
@@ -126,9 +127,10 @@ function formatTeamsOutput(projectUpdate) {
     };
 }
 async function handleAddTeam(projectNameOrId, teamInput, _options, command) {
-    const rootOpts = command.parent.parent.opts();
-    const graphQLService = createGraphQLService(rootOpts);
-    const finalTeamId = await createLinearService(rootOpts).resolveTeamId(resolveTeam(teamInput));
+    const rootOpts = getRootOpts(command);
+    const graphQLService = await createGraphQLService(rootOpts);
+    const linearService = await createLinearService(rootOpts);
+    const finalTeamId = await linearService.resolveTeamId(resolveTeam(teamInput));
     const { projectId, currentTeams } = await resolveProjectWithTeams(graphQLService, projectNameOrId);
     const currentTeamIds = currentTeams.map((t) => t.id);
     if (currentTeamIds.includes(finalTeamId)) {
@@ -149,9 +151,10 @@ async function handleAddTeam(projectNameOrId, teamInput, _options, command) {
     outputSuccess(formatTeamsOutput(projectUpdate));
 }
 async function handleAddTeams(projectNameOrId, teamInputs, _options, command) {
-    const rootOpts = command.parent.parent.opts();
-    const graphQLService = createGraphQLService(rootOpts);
-    const resolvedTeamIds = await Promise.all(teamInputs.map((t) => createLinearService(rootOpts).resolveTeamId(resolveTeam(t))));
+    const rootOpts = getRootOpts(command);
+    const graphQLService = await createGraphQLService(rootOpts);
+    const linearService = await createLinearService(rootOpts);
+    const resolvedTeamIds = await Promise.all(teamInputs.map((t) => linearService.resolveTeamId(resolveTeam(t))));
     const { projectId, currentTeams } = await resolveProjectWithTeams(graphQLService, projectNameOrId);
     const currentTeamIds = currentTeams.map((t) => t.id);
     const newTeamIds = resolvedTeamIds.filter((id) => !currentTeamIds.includes(id));
@@ -181,9 +184,10 @@ async function handleAddTeams(projectNameOrId, teamInputs, _options, command) {
     });
 }
 async function handleRemoveTeam(projectNameOrId, teamInput, options, command) {
-    const rootOpts = command.parent.parent.opts();
-    const graphQLService = createGraphQLService(rootOpts);
-    const finalTeamId = await createLinearService(rootOpts).resolveTeamId(resolveTeam(teamInput));
+    const rootOpts = getRootOpts(command);
+    const graphQLService = await createGraphQLService(rootOpts);
+    const linearService = await createLinearService(rootOpts);
+    const finalTeamId = await linearService.resolveTeamId(resolveTeam(teamInput));
     const { projectId, projectName, currentTeams } = await resolveProjectWithTeams(graphQLService, projectNameOrId);
     const currentTeamIds = currentTeams.map((t) => t.id);
     if (!currentTeamIds.includes(finalTeamId)) {
@@ -220,8 +224,8 @@ async function handleRemoveTeam(projectNameOrId, teamInput, options, command) {
     });
 }
 async function handleCreateProject(name, options, command) {
-    const rootOpts = command.parent.parent.opts();
-    const graphQLService = createGraphQLService(rootOpts);
+    const rootOpts = getRootOpts(command);
+    const graphQLService = await createGraphQLService(rootOpts);
     // Step 1: Check for duplicate projects (case-insensitive)
     const searchResult = await graphQLService.rawRequest(SEARCH_PROJECTS_BY_NAME_QUERY, { name });
     const existing = (searchResult.projects
@@ -236,7 +240,7 @@ async function handleCreateProject(name, options, command) {
             `Use --force to create anyway, or use the existing project.`);
     }
     // Step 2: Resolve team IDs
-    const service = createLinearService(rootOpts);
+    const service = await createLinearService(rootOpts);
     const teamKeys = options.team ? splitList(options.team) : [];
     const teamIds = [];
     for (const key of teamKeys) {
@@ -300,8 +304,8 @@ export function setupProjectsCommands(program) {
         .option("--format <format>", "output format (json, table, md, csv)", "json")
         .option("--fields <fields>", "columns for table/csv (comma-separated: name,state,progress,teams,lead,targetDate)")
         .action(handleAsyncCommand(async (options, command) => {
-        const rootOpts = command.parent.parent.opts();
-        const service = createLinearService(rootOpts);
+        const rootOpts = getRootOpts(command);
+        const service = await createLinearService(rootOpts);
         const result = await service.getProjects(Number.parseInt(options.limit, 10));
         const format = options.format;
         if (format === "table" ||

package/dist/commands/read-shortcut.js

@@ -1,9 +1,10 @@
-import { getApiToken } from "../utils/auth.js";
 import { downloadLinearUploads } from "../utils/download-uploads.js";
+import { createFileService } from "../utils/file-service.js";
 import { GraphQLIssuesService } from "../utils/graphql-issues-service.js";
 import { createGraphQLService } from "../utils/graphql-service.js";
 import { createLinearService } from "../utils/linear-service.js";
 import { handleAsyncCommand, outputSuccess } from "../utils/output.js";
+import { getRootOpts } from "../utils/root-opts.js";
 /**
  * Issue ID pattern: 1-5 uppercase letters, dash, 1+ digits (e.g. ADM-652, DEV-12).
  */
@@ -49,20 +50,20 @@ export function setupReadShortcut(program) {
     };
 }
 async function readIssues(issueIds, _options, command) {
-    const rootOpts = command.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 issuesService = new GraphQLIssuesService(graphQLService, linearService);
-    const apiToken = getApiToken(rootOpts);
+    const fileService = await createFileService(rootOpts);
     if (issueIds.length === 1) {
         const issue = await issuesService.getIssueById(issueIds[0]);
-        const resolved = await downloadLinearUploads(issue, apiToken);
+        const resolved = await downloadLinearUploads(issue, fileService);
         outputSuccess(resolved);
     }
     else {
         const results = await Promise.all(issueIds.map(async (id) => {
             const issue = await issuesService.getIssueById(id);
-            return downloadLinearUploads(issue, apiToken);
+            return downloadLinearUploads(issue, fileService);
         }));
         outputSuccess(results);
     }

package/dist/commands/refs.js

@@ -4,6 +4,7 @@ import { extractIssueReferences } from "../utils/issue-reference-extractor.js";
 import { wrapIssueReferencesAsLinks, } from "../utils/issue-reference-wrapper.js";
 import { createLinearService } from "../utils/linear-service.js";
 import { handleAsyncCommand } 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";
 const VALID_TARGETS = new Set(["markdown", "slack"]);
@@ -58,15 +59,15 @@ async function handleWrap(options, command) {
     const text = typeof options.file === "string" && options.file.length > 0
         ? readFileSync(options.file, "utf8")
         : await readAllStdin();
-    const rootOpts = command.parent.parent.opts();
+    const rootOpts = getRootOpts(command);
     const deps = {
         async resolveValidIdentifiers(ids) {
-            const linearService = createLinearService(rootOpts);
+            const linearService = await createLinearService(rootOpts);
             const map = await validateReferences(ids, linearService);
             return new Set(map.keys());
         },
         async resolveUrlKey() {
-            const graphQLService = createGraphQLService(rootOpts);
+            const graphQLService = await createGraphQLService(rootOpts);
             return getWorkspaceUrlKey(graphQLService);
         },
     };