team-toon-tack 3.5.0 → 3.6.2

package/dist/bin/cli.js

@@ -2,6 +2,7 @@
 import { readFileSync } from "node:fs";
 import { dirname, join, resolve } from "node:path";
 import { fileURLToPath, pathToFileURL } from "node:url";
+import { loadDotEnv, resolveLinearApiKey } from "../scripts/lib/env.js";
 const __dirname = dirname(fileURLToPath(import.meta.url));
 // When running from dist/bin/cli.js, we need to go up two levels to find package.json
 const pkg = JSON.parse(readFileSync(join(__dirname, "..", "..", "package.json"), "utf-8"));
@@ -107,6 +108,10 @@ async function main() {
     const { dir, commandArgs } = parseGlobalArgs(restArgs);
     // Set TOON_DIR for scripts to use
     process.env.TOON_DIR = dir;
+    // Load .ttt/.env (if present) and resolve configured Linear API key env
+    // var into LINEAR_API_KEY so downstream code is workspace-aware.
+    await loadDotEnv(join(dir, ".env"));
+    await resolveLinearApiKey(join(dir, "local.toon"));
     if (!COMMANDS.includes(command)) {
         console.error(`Unknown command: ${command}`);
         console.error(`Run 'ttt help' for usage.`);

package/dist/scripts/init.js

@@ -22,6 +22,7 @@ async function init() {
         localPath: paths.localPath,
         cyclePath: paths.cyclePath,
         outputPath: paths.outputPath,
+        envPath: paths.envPath,
     };
     console.log("🚀 Team Toon Tack Initialization\n");
     // Check existing files

package/dist/scripts/lib/config-builder.d.ts

@@ -39,4 +39,4 @@ export declare function buildConfig(teams: LinearTeam[], users: LinearUser[], la
 export declare function findUserKey(usersConfig: Record<string, UserConfig>, userId: string): string;
 export declare function findUserKeys(usersConfig: Record<string, UserConfig>, userIds: string[]): string[];
 export declare function findTeamKey(teamsConfig: Record<string, TeamConfig>, teamId: string): string;
-export declare function buildLocalConfig(currentUserKey: string | string[], devTeamKey: string, devTestingStatus?: string, qaPmTeams?: QaPmTeamConfig[], completionMode?: CompletionMode, defaultLabels?: string[], excludeLabels?: string[], statusSource?: "remote" | "local"): LocalConfig;
+export declare function buildLocalConfig(currentUserKey: string | string[], devTeamKey: string, devTestingStatus?: string, qaPmTeams?: QaPmTeamConfig[], completionMode?: CompletionMode, defaultLabels?: string[], excludeLabels?: string[], statusSource?: "remote" | "local", linearApiKeyEnv?: string): LocalConfig;

package/dist/scripts/lib/config-builder.js

@@ -113,7 +113,7 @@ export function findTeamKey(teamsConfig, teamId) {
     return (Object.entries(teamsConfig).find(([_, t]) => t.id === teamId)?.[0] ||
         Object.keys(teamsConfig)[0]);
 }
-export function buildLocalConfig(currentUserKey, devTeamKey, devTestingStatus, qaPmTeams, completionMode, defaultLabels, excludeLabels, statusSource) {
+export function buildLocalConfig(currentUserKey, devTeamKey, devTestingStatus, qaPmTeams, completionMode, defaultLabels, excludeLabels, statusSource, linearApiKeyEnv) {
     return {
         current_user: currentUserKey,
         team: devTeamKey,
@@ -123,5 +123,8 @@ export function buildLocalConfig(currentUserKey, devTeamKey, devTestingStatus, q
         labels: defaultLabels && defaultLabels.length > 0 ? defaultLabels : undefined,
         exclude_labels: excludeLabels && excludeLabels.length > 0 ? excludeLabels : undefined,
         status_source: statusSource,
+        linear_api_key_env: linearApiKeyEnv && linearApiKeyEnv !== "LINEAR_API_KEY"
+            ? linearApiKeyEnv
+            : undefined,
     };
 }

package/dist/scripts/lib/env.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Minimal .env file loader and writer.
+ * No external dependency. Values already in process.env take precedence
+ * over values loaded from the file.
+ */
+/** Populate process.env from envPath. Existing process.env values win. */
+export declare function loadDotEnv(envPath: string): Promise<void>;
+/**
+ * Read linear_api_key_env from local.toon and mirror the chosen env var
+ * into LINEAR_API_KEY. No-op if local.toon is missing or the field is
+ * absent/default. Uses substring parsing to avoid importing the Linear SDK
+ * at CLI startup.
+ */
+export declare function resolveLinearApiKey(localPath: string): Promise<void>;
+/** Merge vars into envPath, preserving existing entries. Creates with 0600. */
+export declare function writeDotEnv(envPath: string, vars: Record<string, string>): Promise<void>;

package/dist/scripts/lib/env.js

@@ -0,0 +1,86 @@
+/**
+ * Minimal .env file loader and writer.
+ * No external dependency. Values already in process.env take precedence
+ * over values loaded from the file.
+ */
+import fs from "node:fs/promises";
+const ENV_LINE = /^([A-Z_][A-Z0-9_]*)\s*=\s*(.*)$/i;
+function parseEnv(content) {
+    const result = {};
+    for (const rawLine of content.split("\n")) {
+        const line = rawLine.trim();
+        if (!line || line.startsWith("#"))
+            continue;
+        const match = line.match(ENV_LINE);
+        if (!match)
+            continue;
+        let value = match[2];
+        if ((value.startsWith('"') && value.endsWith('"')) ||
+            (value.startsWith("'") && value.endsWith("'"))) {
+            value = value.slice(1, -1);
+        }
+        result[match[1]] = value;
+    }
+    return result;
+}
+function quoteIfNeeded(value) {
+    if (/[\s"'#]/.test(value)) {
+        return `"${value.replace(/"/g, '\\"')}"`;
+    }
+    return value;
+}
+/** Populate process.env from envPath. Existing process.env values win. */
+export async function loadDotEnv(envPath) {
+    let content;
+    try {
+        content = await fs.readFile(envPath, "utf-8");
+    }
+    catch {
+        return;
+    }
+    const parsed = parseEnv(content);
+    for (const [key, value] of Object.entries(parsed)) {
+        if (process.env[key] === undefined) {
+            process.env[key] = value;
+        }
+    }
+}
+/**
+ * Read linear_api_key_env from local.toon and mirror the chosen env var
+ * into LINEAR_API_KEY. No-op if local.toon is missing or the field is
+ * absent/default. Uses substring parsing to avoid importing the Linear SDK
+ * at CLI startup.
+ */
+export async function resolveLinearApiKey(localPath) {
+    let content;
+    try {
+        content = await fs.readFile(localPath, "utf-8");
+    }
+    catch {
+        return;
+    }
+    const match = content.match(/^linear_api_key_env\s*:\s*["']?([A-Z_][A-Z0-9_]*)["']?\s*$/im);
+    const envName = match?.[1];
+    if (!envName || envName === "LINEAR_API_KEY")
+        return;
+    const value = process.env[envName];
+    if (value) {
+        process.env.LINEAR_API_KEY = value;
+    }
+}
+/** Merge vars into envPath, preserving existing entries. Creates with 0600. */
+export async function writeDotEnv(envPath, vars) {
+    let existing = {};
+    try {
+        const content = await fs.readFile(envPath, "utf-8");
+        existing = parseEnv(content);
+    }
+    catch {
+        // no existing file
+    }
+    const merged = { ...existing, ...vars };
+    const body = `${Object.entries(merged)
+        .map(([k, v]) => `${k}=${quoteIfNeeded(v)}`)
+        .join("\n")}\n`;
+    await fs.writeFile(envPath, body, { mode: 0o600 });
+}

package/dist/scripts/lib/init/file-ops.js

@@ -5,7 +5,8 @@ import fs from "node:fs/promises";
 import { confirm } from "@inquirer/prompts";
 export async function updateGitignore(tttDir, interactive) {
     const gitignorePath = ".gitignore";
-    const entry = `${tttDir}/`;
+    const tttEntry = `${tttDir}/`;
+    const envEntry = ".env";
     try {
         let content = "";
         let exists = false;
@@ -16,32 +17,37 @@ export async function updateGitignore(tttDir, interactive) {
         catch {
             // .gitignore doesn't exist
         }
-        // Check if already ignored
-        const lines = content.split("\n");
-        const alreadyIgnored = lines.some((line) => line.trim() === entry ||
-            line.trim() === tttDir ||
-            line.trim() === `/${entry}` ||
-            line.trim() === `/${tttDir}`);
-        if (alreadyIgnored) {
+        const lines = content.split("\n").map((l) => l.trim());
+        const hasTtt = lines.some((line) => line === tttEntry ||
+            line === tttDir ||
+            line === `/${tttEntry}` ||
+            line === `/${tttDir}`);
+        const hasEnv = lines.some((line) => line === envEntry || line === "/.env");
+        const toAdd = [];
+        if (!hasTtt)
+            toAdd.push(tttEntry);
+        if (!hasEnv)
+            toAdd.push(envEntry);
+        if (toAdd.length === 0)
             return;
-        }
-        // Ask user in interactive mode
         if (interactive) {
             const addToGitignore = await confirm({
-                message: `Add ${entry} to .gitignore?`,
+                message: `Add ${toAdd.join(" and ")} to .gitignore?`,
                 default: true,
             });
             if (!addToGitignore)
                 return;
         }
-        // Add to .gitignore
+        const suffix = `${toAdd.join("\n")}\n`;
         const newContent = exists
             ? content.endsWith("\n")
-                ? `${content}${entry}\n`
-                : `${content}\n${entry}\n`
-            : `${entry}\n`;
+                ? `${content}${suffix}`
+                : `${content}\n${suffix}`
+            : suffix;
         await fs.writeFile(gitignorePath, newContent, "utf-8");
-        console.log(`  ✓ Added ${entry} to .gitignore`);
+        for (const entry of toAdd) {
+            console.log(`  ✓ Added ${entry} to .gitignore`);
+        }
     }
     catch (_error) {
         // Silently ignore gitignore errors

package/dist/scripts/lib/init/linear-init.js

@@ -2,21 +2,42 @@
  * Linear initialization flow
  */
 import fs from "node:fs/promises";
+import { confirm } from "@inquirer/prompts";
 import { decode, encode } from "@toon-format/toon";
 import { fileExists, getLinearClient, } from "../../utils.js";
 import { buildConfig, buildLocalConfig, buildTeamsConfig, findTeamKey, findUserKey, findUserKeys, } from "../config-builder.js";
+import { writeDotEnv } from "../env.js";
 import { formatTodoStatus } from "../status-helpers.js";
 import { showPluginInstallInstructions, updateGitignore } from "./file-ops.js";
 import { promptForApiKey, selectCompletionMode, selectDevTeam, selectDevTestingStatus, selectQaPmTeams, selectStatusMappings, } from "./linear-prompts.js";
 import { selectLabelFilter, selectStatusSource, selectUsers, } from "./prompts.js";
 export async function initLinear(options, paths) {
-    // Get API key
-    const apiKey = await promptForApiKey(options);
-    if (!apiKey) {
+    // Get API key (workspace-aware)
+    const resolved = await promptForApiKey(options);
+    if (!resolved) {
         console.error("Error: LINEAR_API_KEY is required.");
         console.error("Get your API key from: https://linear.app/settings/api");
         process.exit(1);
     }
+    const { apiKey, envName, fromSystemEnv } = resolved;
+    // Mirror into LINEAR_API_KEY so getLinearClient() picks it up regardless
+    // of which env var name the user selected.
+    process.env.LINEAR_API_KEY = apiKey;
+    // Offer to persist to project-root .env so dotenv-aware tools (and future
+    // ttt runs) can reuse it without relying on the user's shell profile.
+    console.log("\n🔐 Local .env file:");
+    console.log(`  Path: ${paths.envPath}${fromSystemEnv ? " (you already have this key in your shell — this just pins it per-project)" : ""}`);
+    let saveToEnvFile = false;
+    if (options.interactive) {
+        saveToEnvFile = await confirm({
+            message: `Write ${envName} to ${paths.envPath}?`,
+            default: true,
+        });
+    }
+    if (saveToEnvFile) {
+        await writeDotEnv(paths.envPath, { [envName]: apiKey });
+        console.log(`  ✓ Wrote ${envName} to ${paths.envPath}`);
+    }
     // Create Linear client
     const client = getLinearClient();
     console.log("\n📡 Fetching data from Linear...");
@@ -120,7 +141,7 @@ export async function initLinear(options, paths) {
     const currentUserValue = currentUserKeys.length === 1 ? currentUserKeys[0] : currentUserKeys;
     const devTeamKey = findTeamKey(config.teams, devTeam.id);
     const localConfig = buildLocalConfig(currentUserValue, devTeamKey, devTestingStatus, qaPmTeams, completionMode, defaultLabel, undefined, // excludeLabels
-    statusSource);
+    statusSource, envName);
     // Write config files
     console.log("\n📝 Writing configuration files...");
     await fs.mkdir(paths.baseDir, { recursive: true });
@@ -131,7 +152,9 @@ export async function initLinear(options, paths) {
     if (configExists && !options.force) {
         try {
             const existingContent = await fs.readFile(paths.configPath, "utf-8");
-            const existingConfig = decode(existingContent, { strict: false });
+            const existingConfig = decode(existingContent, {
+                strict: false,
+            });
             if (existingConfig.cycle_history) {
                 config.cycle_history = existingConfig.cycle_history;
             }
@@ -152,7 +175,9 @@ export async function initLinear(options, paths) {
     if (localExists && !options.force) {
         try {
             const existingContent = await fs.readFile(paths.localPath, "utf-8");
-            const existingLocal = decode(existingContent, { strict: false });
+            const existingLocal = decode(existingContent, {
+                strict: false,
+            });
             if (!options.interactive) {
                 if (existingLocal.current_user)
                     localConfig.current_user = existingLocal.current_user;
@@ -170,6 +195,8 @@ export async function initLinear(options, paths) {
                     localConfig.exclude_labels = existingLocal.exclude_labels;
                 if (existingLocal.status_source)
                     localConfig.status_source = existingLocal.status_source;
+                if (existingLocal.linear_api_key_env)
+                    localConfig.linear_api_key_env = existingLocal.linear_api_key_env;
             }
         }
         catch {
@@ -183,6 +210,12 @@ export async function initLinear(options, paths) {
     // Summary
     console.log("\n✅ Initialization complete!\n");
     console.log("Configuration summary:");
+    if (resolved.organizationName) {
+        console.log(`  Workspace: ${resolved.organizationName} (via ${envName})`);
+    }
+    else {
+        console.log(`  API key env: ${envName}`);
+    }
     console.log(`  Dev Team: ${devTeam.name}`);
     if (selectedUsers.length === 0) {
         console.log("  Users: (all team members)");
@@ -217,11 +250,11 @@ export async function initLinear(options, paths) {
         console.log(`    Blocked: ${statusTransitions.blocked}`);
     }
     console.log("\nNext steps:");
-    if (!process.env.LINEAR_API_KEY) {
-        // Show partial key for confirmation (first 12 chars + masked)
+    const needsShellExport = !saveToEnvFile && !fromSystemEnv;
+    if (needsShellExport) {
         const maskedKey = `${apiKey.slice(0, 12)}...${"*".repeat(8)}`;
-        console.log("  1. Set LINEAR_API_KEY in your shell profile:");
-        console.log(`     export LINEAR_API_KEY="${maskedKey}"`);
+        console.log(`  1. Set ${envName} in your shell profile:`);
+        console.log(`     export ${envName}="${maskedKey}"`);
         console.log("  2. Run sync: ttt sync");
         console.log("  3. Start working: ttt work-on");
     }

package/dist/scripts/lib/init/linear-prompts.d.ts

@@ -4,7 +4,18 @@
 import type { CompletionMode, QaPmTeamConfig, StatusTransitions } from "../../utils.js";
 import { type LinearState, type LinearTeam } from "../config-builder.js";
 import type { InitOptions } from "./types.js";
-export declare function promptForApiKey(options: InitOptions): Promise<string | undefined>;
+export interface ResolvedApiKey {
+    apiKey: string;
+    envName: string;
+    fromSystemEnv: boolean;
+    organizationName?: string;
+}
+/**
+ * Detect available Linear API keys from process.env, probe each for its
+ * workspace, and let the user pick. Supports adding a new key inline.
+ * Returns the chosen key plus the env var name that holds it.
+ */
+export declare function promptForApiKey(options: InitOptions): Promise<ResolvedApiKey | undefined>;
 export declare function selectDevTeam(teams: LinearTeam[], options: InitOptions): Promise<LinearTeam>;
 export declare function selectDevTestingStatus(devStates: LinearState[], options: InitOptions): Promise<string | undefined>;
 export declare function selectQaPmTeams(teams: LinearTeam[], devTeam: LinearTeam, teamStatesMap: Map<string, LinearState[]>, teamsConfig: Record<string, {

package/dist/scripts/lib/init/linear-prompts.js

@@ -1,20 +1,136 @@
 /**
  * Linear-specific prompt functions for init
  */
-import { checkbox, password, select } from "@inquirer/prompts";
+import { checkbox, input, password, select } from "@inquirer/prompts";
+import { LinearClient } from "@linear/sdk";
 import { getDefaultStatusTransitions, } from "../config-builder.js";
 import { getFirstTodoStatus } from "../status-helpers.js";
+function collectEnvCandidates() {
+    const candidates = [];
+    for (const [name, value] of Object.entries(process.env)) {
+        if (!value)
+            continue;
+        if (name === "LINEAR_API_KEY" || name.startsWith("LINEAR_API_KEY_")) {
+            if (value.startsWith("lin_api_")) {
+                candidates.push({ envName: name, apiKey: value });
+            }
+        }
+    }
+    return candidates;
+}
+async function probeWorkspace(candidate) {
+    try {
+        const client = new LinearClient({ apiKey: candidate.apiKey });
+        const org = await client.organization;
+        candidate.orgName = org.name;
+        candidate.orgUrlKey = org.urlKey;
+    }
+    catch (err) {
+        candidate.error = err instanceof Error ? err.message : String(err);
+    }
+}
+function validateApiKey(v) {
+    return v.startsWith("lin_api_")
+        ? true
+        : 'API key should start with "lin_api_"';
+}
+/**
+ * Detect available Linear API keys from process.env, probe each for its
+ * workspace, and let the user pick. Supports adding a new key inline.
+ * Returns the chosen key plus the env var name that holds it.
+ */
 export async function promptForApiKey(options) {
-    let apiKey = options.apiKey || process.env.LINEAR_API_KEY;
-    if (!apiKey && options.interactive) {
-        apiKey = await password({
-            message: "Enter your Linear API key:",
-            validate: (v) => v.startsWith("lin_api_")
-                ? true
-                : 'API key should start with "lin_api_"',
+    // Non-interactive: use --api-key or LINEAR_API_KEY, no selection possible
+    if (!options.interactive) {
+        const apiKey = options.apiKey || process.env.LINEAR_API_KEY;
+        if (!apiKey)
+            return undefined;
+        return {
+            apiKey,
+            envName: "LINEAR_API_KEY",
+            fromSystemEnv: !options.apiKey && !!process.env.LINEAR_API_KEY,
+        };
+    }
+    // --api-key flag short-circuits the workspace picker
+    if (options.apiKey) {
+        return {
+            apiKey: options.apiKey,
+            envName: "LINEAR_API_KEY",
+            fromSystemEnv: false,
+        };
+    }
+    const envCandidates = collectEnvCandidates();
+    if (envCandidates.length > 0) {
+        console.log(`\n🔑 Found ${envCandidates.length} Linear API key${envCandidates.length > 1 ? "s" : ""} in environment. Probing workspaces...`);
+        await Promise.all(envCandidates.map(probeWorkspace));
+        for (const c of envCandidates) {
+            if (c.error) {
+                console.log(`  ✗ ${c.envName} — error: ${c.error}`);
+            }
+            else {
+                console.log(`  ✓ ${c.envName} → ${c.orgName ?? "?"}${c.orgUrlKey ? ` (${c.orgUrlKey})` : ""}`);
+            }
+        }
+        const valid = envCandidates.filter((c) => !c.error);
+        const choices = [
+            ...valid.map((c) => ({
+                name: `${c.orgName ?? "(unknown)"}  [${c.envName}]`,
+                value: c.envName,
+                description: c.orgUrlKey ? `${c.orgUrlKey}.linear.app` : undefined,
+            })),
+            { name: "+ Enter a different API key", value: "__new__" },
+        ];
+        const chosen = await select({
+            message: "Select workspace:",
+            choices,
         });
+        if (chosen !== "__new__") {
+            const picked = valid.find((c) => c.envName === chosen);
+            if (picked) {
+                return {
+                    apiKey: picked.apiKey,
+                    envName: picked.envName,
+                    fromSystemEnv: true,
+                    organizationName: picked.orgName,
+                };
+            }
+        }
     }
-    return apiKey;
+    // No env keys, or user chose to enter a new one
+    const apiKey = await password({
+        message: "Enter your Linear API key:",
+        validate: validateApiKey,
+    });
+    const newCandidate = {
+        envName: "LINEAR_API_KEY",
+        apiKey,
+    };
+    await probeWorkspace(newCandidate);
+    if (newCandidate.error) {
+        console.error(`  ✗ Failed to fetch workspace: ${newCandidate.error}`);
+        return undefined;
+    }
+    console.log(`  ✓ Workspace: ${newCandidate.orgName}${newCandidate.orgUrlKey ? ` (${newCandidate.orgUrlKey})` : ""}`);
+    // Ask for env var name (default to a slugged workspace name if LINEAR_API_KEY is taken)
+    const defaultName = process.env.LINEAR_API_KEY
+        ? `LINEAR_API_KEY_${(newCandidate.orgUrlKey ??
+            newCandidate.orgName ??
+            "ALT")
+            .toUpperCase()
+            .replace(/[^A-Z0-9]/g, "_")}`
+        : "LINEAR_API_KEY";
+    const envName = await input({
+        message: "Env variable name to store this key under:",
+        default: defaultName,
+        validate: (v) => /^[A-Z_][A-Z0-9_]*$/.test(v) ||
+            "Env var names must be uppercase letters, digits, underscore",
+    });
+    return {
+        apiKey,
+        envName,
+        fromSystemEnv: false,
+        organizationName: newCandidate.orgName,
+    };
 }
 export async function selectDevTeam(teams, options) {
     let devTeam = teams[0];

package/dist/scripts/lib/init/types.d.ts

@@ -19,5 +19,6 @@ export interface InitPaths {
     localPath: string;
     cyclePath: string;
     outputPath: string;
+    envPath: string;
 }
 export type { TaskSourceType };

package/dist/scripts/utils.d.ts

@@ -6,6 +6,7 @@ export declare function getPaths(): {
     cyclePath: string;
     localPath: string;
     outputPath: string;
+    envPath: string;
 };
 export interface TeamConfig {
     id: string;
@@ -126,6 +127,7 @@ export interface LocalConfig {
     exclude_labels?: string[];
     labels?: string[];
     status_source?: "remote" | "local";
+    linear_api_key_env?: string;
     teams?: string[];
     qa_pm_team?: string;
 }

package/dist/scripts/utils.js

@@ -22,6 +22,7 @@ const CONFIG_PATH = path.join(BASE_DIR, "config.toon");
 const CYCLE_PATH = path.join(BASE_DIR, "cycle.toon");
 const LOCAL_PATH = path.join(BASE_DIR, "local.toon");
 const OUTPUT_PATH = path.join(BASE_DIR, "output");
+const ENV_PATH = path.join(BASE_DIR, ".env");
 export function getPaths() {
     return {
         baseDir: BASE_DIR,
@@ -29,6 +30,7 @@ export function getPaths() {
         cyclePath: CYCLE_PATH,
         localPath: LOCAL_PATH,
         outputPath: OUTPUT_PATH,
+        envPath: ENV_PATH,
     };
 }
 // Linear priority value to name mapping (fixed by Linear API)

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "team-toon-tack",
-	"version": "3.5.0",
+	"version": "3.6.2",
 	"description": "Linear & Trello task sync & management CLI with TOON format",
 	"type": "module",
 	"bin": {