ticketlens 0.1.6 → 0.1.8

package/README.md

@@ -190,6 +190,19 @@ Stores the schedule as a cron entry. Delivers your triage digest at the configur
 
 ---
 
+### Login
+
+```bash
+ticketlens login           # Open browser → authorize in Console → token saved automatically
+ticketlens login --manual  # Paste a token instead (CI/headless environments)
+```
+
+`ticketlens login` opens the TicketLens Console in your default browser. Click **Authorize**, and the CLI receives your token via a one-shot localhost callback — no copy-pasting. Cancelling in the browser exits the CLI cleanly.
+
+Use `--manual` when there is no GUI (CI runners, SSH sessions, containers).
+
+---
+
 ### License
 
 ```bash
@@ -308,6 +321,10 @@ ticketlens schedule                           # Interactive wizard — set time,
 ticketlens schedule --stop                    # Cancel the scheduled digest [Pro]
 ticketlens schedule --status                  # Show current schedule [Pro]
 
+# ── Login ─────────────────────────────────────────────────────────────────────
+ticketlens login                              # Browser flow — opens Console, token saved automatically
+ticketlens login --manual                     # Paste flow — for CI/headless environments
+
 # ── License and account ────────────────────────────────────────────────────────
 ticketlens license                            # Show license tier and status
 ticketlens activate <LICENSE-KEY>             # Activate a license key

package/bin/ticketlens.mjs

@@ -309,9 +309,12 @@ switch (command) {
         try {
           token = await browserLogin();
         } catch (err) {
-          process.stderr.write(`\x1b[A\r\x1b[2K  ${s.red('✖')} ${err.message}\n`);
-          process.stderr.write(`\n  ${s.dim(`Try ${s.cyan('ticketlens login --manual')} to paste a token instead.`)}\n\n`);
-          process.exitCode = 1;
+          const cancelled = err.message === 'Authorization cancelled';
+          process.stderr.write(`\x1b[A\r\x1b[2K  ${s.red('✖')} ${cancelled ? 'Login cancelled.' : err.message}\n`);
+          if (!cancelled) {
+            process.stderr.write(`\n  ${s.dim(`Try ${s.cyan('ticketlens login --manual')} to paste a token instead.`)}\n\n`);
+          }
+          process.exitCode = cancelled ? 0 : 1;
           return;
         }
       }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ticketlens",
-  "version": "0.1.6",
+  "version": "0.1.8",
   "description": "Jira CLI for developers — fetch ticket context, triage your queue, and stop tab-switching. Zero dependencies, all local.",
   "type": "module",
   "bin": {

package/skills/jtb/scripts/lib/adapters/linear-adapter.mjs

@@ -0,0 +1,132 @@
+const LINEAR_API = 'https://api.linear.app/graphql';
+
+const PRIORITY_LABELS = { 1: 'Urgent', 2: 'High', 3: 'Medium', 4: 'Low' };
+
+const ISSUE_FIELDS = `
+  identifier
+  title
+  description
+  state { name }
+  priority
+  assignee { name displayName email }
+  creator { name displayName email }
+  createdAt
+  updatedAt
+  labels { nodes { name } }
+  comments { nodes { body createdAt user { name displayName email } } }
+`;
+
+/**
+ * Maps a raw Linear GraphQL issue node to the normalized ticket shape.
+ */
+export function normalizeLinearIssue(raw) {
+  return {
+    key: raw.identifier,
+    summary: raw.title,
+    type: 'Issue',
+    status: raw.state?.name ?? null,
+    priority: PRIORITY_LABELS[raw.priority] ?? null,
+    assignee: raw.assignee?.displayName ?? raw.assignee?.name ?? null,
+    reporter: raw.creator?.displayName ?? raw.creator?.name ?? null,
+    description: raw.description ?? null,
+    created: raw.createdAt ?? null,
+    updated: raw.updatedAt ?? null,
+    labels: (raw.labels?.nodes ?? []).map(l => l.name),
+    components: [],
+    comments: (raw.comments?.nodes ?? []).map(c => ({
+      author: c.user?.displayName ?? c.user?.name ?? null,
+      authorAccountId: null,
+      authorName: c.user?.name ?? null,
+      body: c.body ?? '',
+      created: c.createdAt ?? null,
+    })),
+    linkedIssues: [],
+    attachments: [],
+  };
+}
+
+async function gql(query, variables, { token, fetcher, signal }) {
+  const res = await fetcher(LINEAR_API, {
+    method: 'POST',
+    headers: {
+      Authorization: `Bearer ${token}`,
+      'Content-Type': 'application/json',
+    },
+    body: JSON.stringify({ query, variables }),
+    signal,
+  });
+  if (!res.ok) {
+    throw new Error(`Linear API error ${res.status} (${res.statusText})`);
+  }
+  const { data, errors } = await res.json();
+  if (errors?.length) throw new Error(`Linear GraphQL error: ${errors[0].message}`);
+  return data;
+}
+
+/**
+ * Returns a tracker adapter backed by the Linear GraphQL API.
+ * Profile baseUrl must contain linear.app. Auth token stored as apiToken in credentials.json.
+ */
+export function createLinearAdapter(conn, { fetcher = globalThis.fetch } = {}) {
+  const token = conn.apiToken || conn.pat;
+
+  return {
+    type: 'linear',
+
+    async fetchTicket(key, opts = {}) {
+      const signal = AbortSignal.timeout(opts.timeoutMs ?? 10_000);
+      const data = await gql(
+        `query IssueByIdentifier($id: String!) {
+          issues(filter: { identifier: { eq: $id } }, first: 1) {
+            nodes { ${ISSUE_FIELDS} }
+          }
+        }`,
+        { id: key },
+        { token, fetcher, signal },
+      );
+      const node = data.issues?.nodes?.[0];
+      if (!node) throw new Error(`Linear issue not found: ${key}`);
+      return normalizeLinearIssue(node);
+    },
+
+    async fetchCurrentUser(opts = {}) {
+      const signal = AbortSignal.timeout(opts.timeoutMs ?? 10_000);
+      const data = await gql(
+        `query Me { viewer { name displayName email } }`,
+        {},
+        { token, fetcher, signal },
+      );
+      const v = data.viewer;
+      return { displayName: v.displayName ?? v.name, email: v.email ?? null };
+    },
+
+    async searchTickets(_query, opts = {}) {
+      const signal = AbortSignal.timeout(opts.timeoutMs ?? 10_000);
+      const data = await gql(
+        `query MyIssues {
+          viewer {
+            assignedIssues(
+              filter: { state: { type: { nin: ["completed", "cancelled"] } } }
+              first: 50
+            ) {
+              nodes { ${ISSUE_FIELDS} }
+            }
+          }
+        }`,
+        {},
+        { token, fetcher, signal },
+      );
+      return (data.viewer?.assignedIssues?.nodes ?? []).map(normalizeLinearIssue);
+    },
+
+    async fetchStatuses(opts = {}) {
+      const signal = AbortSignal.timeout(opts.timeoutMs ?? 10_000);
+      const data = await gql(
+        `query WorkflowStates { workflowStates(first: 50) { nodes { name } } }`,
+        {},
+        { token, fetcher, signal },
+      );
+      return (data.workflowStates?.nodes ?? []).map(s => s.name);
+    },
+  };
+}

package/skills/jtb/scripts/lib/browser-login.mjs

@@ -49,6 +49,7 @@ export function startLocalServer(port, expectedState, timeoutMs = TIMEOUT_MS) {
 
       const token = url.searchParams.get('token') ?? '';
       const state = url.searchParams.get('state') ?? '';
+      const error = url.searchParams.get('error') ?? '';
 
       if (state !== expectedState) {
         res.writeHead(400, { 'Content-Type': 'text/plain' });
@@ -57,6 +58,18 @@ export function startLocalServer(port, expectedState, timeoutMs = TIMEOUT_MS) {
         return;
       }
 
+      if (error) {
+        res.writeHead(200, { 'Content-Type': 'text/html' });
+        res.end(
+          '<html><body style="font-family:sans-serif;text-align:center;padding:60px;background:#0d1117;color:#cdd9e5">'
+          + '<h2 style="color:#8b949e">Authorization cancelled</h2>'
+          + '<p style="color:#8b949e">You can close this tab.</p>'
+          + '</body></html>',
+        );
+        settle(reject, new Error('Authorization cancelled'));
+        return;
+      }
+
       if (!token.startsWith('tl_')) {
         res.writeHead(400, { 'Content-Type': 'text/plain' });
         res.end('Invalid token received.');

package/skills/jtb/scripts/lib/init-wizard.mjs

@@ -109,6 +109,7 @@ async function _run({ configDir, stream, s }) {
     const TRACKER_TYPES = [
       { label: 'Jira',   sublabel: 'Jira Cloud, Server, or Data Center', value: 'jira'   },
       { label: 'GitHub', sublabel: 'GitHub Issues (github.com)',          value: 'github' },
+      { label: 'Linear', sublabel: 'Linear (linear.app)',                 value: 'linear' },
     ];
     stream.write(`\n  ${s.dim('Tracker type:')}\n\n`);
     const trackerIndex = await promptSelect(TRACKER_TYPES, { stream, hint: '↑/↓ select   Enter confirm' });
@@ -230,6 +231,96 @@ async function _run({ configDir, stream, s }) {
       }
     }
 
+    if (trackerType === 'linear') {
+      let linToken = '';
+
+      linearLoop: while (true) {
+        const tokenHint = linToken ? s.dim('  [keep existing]') : '';
+        linToken = await promptSecret(
+          s.dim('Linear API key') + tokenHint + s.dim(':'),
+          { stream, existingValue: linToken }
+        );
+
+        const linConn = { baseUrl: 'https://linear.app', apiToken: linToken };
+        const linSession = createSession({ baseUrl: 'https://linear.app', profileName }, { stream });
+        stream.write('\n');
+        linSession.spin('Testing connection...');
+
+        try {
+          const linAdapter = resolveAdapter(linConn);
+          await linAdapter.fetchCurrentUser();
+          linSession.connected();
+          connected = true;
+          break linearLoop;
+        } catch (err) {
+          linSession.failed();
+          const classified = classifyError(err, { baseUrl: 'https://linear.app', profileName });
+          linSession.footer(classified.message, 'error', classified.hint);
+        }
+
+        const LIN_RETRY = [
+          { label: 'Retry',     sublabel: 'Try again — same key',          value: 'retry' },
+          { label: 'Edit key',  sublabel: 'Change API key',                 value: 'creds' },
+          { label: 'Skip',      sublabel: 'Abandon — move to next step',    value: 'skip'  },
+        ];
+        stream.write(`\n  ${s.dim('What would you like to do?')}\n\n`);
+        const linRetryIndex = await promptSelect(LIN_RETRY, { stream, hint: '↑/↓ select   Enter confirm' });
+        if (linRetryIndex === null || LIN_RETRY[linRetryIndex].value === 'skip') break linearLoop;
+        const lHint = linToken ? s.dim('  [keep existing]') : '';
+        linToken = await promptSecret(
+          s.dim('Linear API key') + lHint + s.dim(':'),
+          { stream, existingValue: linToken }
+        );
+      }
+
+      if (connected) {
+        stream.write(`\n  ${s.dim('──── Optional  (press Enter to skip) ────')}\n\n`);
+
+        const prefixRaw = await promptText(s.dim('Team identifier') + s.dim('  (e.g. ENG):'), { stream });
+        const ticketPrefixes = prefixRaw
+          ? prefixRaw.split(',').map(v => v.trim().toUpperCase()).filter(Boolean)
+          : [];
+
+        const home = homedir();
+        const cwd = process.cwd();
+        const cwdDisplay = cwd.startsWith(home) ? '~' + cwd.slice(home.length) : cwd;
+        const pathInput = await promptText(
+          s.dim('Project path') + s.dim(`  [${cwdDisplay}]:`), { stream }
+        );
+        const rawPath = (pathInput.trim() || cwdDisplay).replace(/\/+$/, '');
+        const projectPaths = [];
+        if (rawPath) {
+          const expanded = rawPath.startsWith('~') ? join(home, rawPath.slice(1)) : rawPath;
+          if (existsSync(expanded)) {
+            projectPaths.push(rawPath);
+            stream.write(`  ${s.green('✔')} ${rawPath}\n`);
+          } else {
+            stream.write(`  ${s.yellow('○')} ${s.dim(rawPath)} — directory not found\n`);
+            const doCreate = await promptYN(`Create ${rawPath}?`, { stream });
+            if (doCreate) {
+              try {
+                mkdirSync(expanded, { recursive: true });
+                projectPaths.push(rawPath);
+                stream.write(`  ${s.green('✔')} Created\n`);
+              } catch (mkErr) {
+                stream.write(`  ${s.red('✖')} Could not create: ${mkErr.message}\n`);
+              }
+            }
+          }
+        }
+
+        const profileData = {
+          baseUrl: 'https://linear.app',
+          auth: 'linear',
+          ...(ticketPrefixes.length > 0 ? { ticketPrefixes } : {}),
+          ...(projectPaths.length > 0 ? { projectPaths } : {}),
+        };
+        saveProfile(profileName, profileData, { apiToken: linToken }, configDir);
+        addedCount++;
+        stream.write(`\n  ${s.green('✔')} Profile ${s.bold(s.cyan(`"${profileName}"`))} saved.\n`);
+      }
+    }
+
     if (trackerType === 'jira') {
     // ── Setup loop — URL → auth → credentials → test → retry ─────────────────
     //

package/skills/jtb/scripts/lib/resolve-adapter.mjs

@@ -1,5 +1,6 @@
 import { createJiraAdapter } from './adapters/jira-adapter.mjs';
 import { createGitHubAdapter } from './adapters/github-adapter.mjs';
+import { createLinearAdapter } from './adapters/linear-adapter.mjs';
 
 /**
  * Detects the tracker type from a baseUrl string.
@@ -24,5 +25,6 @@ export function resolveAdapter(conn, opts = {}) {
   const type = detectTrackerType(conn?.baseUrl);
   if (type === 'jira') return createJiraAdapter(conn, opts);
   if (type === 'github') return createGitHubAdapter(conn, opts);
-  throw new Error(`Tracker type '${type}' is not yet supported. Supported: jira, github.`);
+  if (type === 'linear') return createLinearAdapter(conn, opts);
+  throw new Error(`Tracker type '${type}' is not yet supported. Supported: jira, github, linear.`);
 }