atris 3.34.0 → 3.35.0

package/commands/now.js

@@ -201,6 +201,25 @@ function countTaskReceiptsToday(root = process.cwd(), date = new Date()) {
   return seen.size;
 }
 
+function compactLine(value) {
+  return String(value || '').replace(/\s+/g, ' ').trim();
+}
+
+function currentMissionMoveLine(root = process.cwd()) {
+  try {
+    const { selectCodexGoalMission, codexGoalNextCommand } = require('./mission');
+    const selected = selectCodexGoalMission(root);
+    const mission = selected?.mission || null;
+    if (!mission) return null;
+    const objective = compactLine(mission.objective);
+    const next = compactLine(codexGoalNextCommand(mission));
+    if (!objective || !next) return null;
+    return `The move: ${objective} — next: ${next}`;
+  } catch {
+    return null;
+  }
+}
+
 function currentJournalPath(root = process.cwd()) {
   const now = new Date();
   const year = String(now.getFullYear());
@@ -218,6 +237,10 @@ function renderDefaultNow(root = process.cwd()) {
   const taskReceiptCount = countTaskReceiptsToday(root);
   const completedCount = taskReceiptCount || countJournalCompletedReceipts(journalPath);
   const generated = todayIso();
+  const moveLine = currentMissionMoveLine(root);
+  const whatMattersNow = moveLine
+    ? `${moveLine}\n\n- Decide the next useful move before opening more context.`
+    : '- Decide the next useful move before opening more context.';
 
   return `# now
 
@@ -228,7 +251,7 @@ Last updated: ${generated}
 
 ## What Matters Now
 
-- Decide the next useful move before opening more context.
+${whatMattersNow}
 
 ## Current Priority
 
@@ -425,6 +448,7 @@ module.exports = {
   countOpenWorkItems,
   countOpenTodoItems,
   countTaskReceiptsToday,
+  currentMissionMoveLine,
   findChildWorkspaces,
   isGeneratedNowFile,
   nowAtris,

package/commands/radar.js

@@ -100,6 +100,7 @@ function collectAgents(deps) {
       return {
         pid: row.pid,
         agent: row.agent,
+        command: row.command,
         status: row.stat.includes('Z') ? 'zombie' : row.stat.includes('T') ? 'stopped' : 'active',
         cwd,
         repo: repoLabel(cwd),
@@ -148,7 +149,8 @@ function loadTasksCached(root, deps, cache) {
   return cache.get(root);
 }
 
-function untaskedReason(agent, taskWorkspaceRoot, tasks) {
+function untaskedReason(agent, taskWorkspaceRoot, tasks, binding = null) {
+  if (binding?.interactive) return 'interactive session';
   if (!agent.cwd) return 'cwd unknown';
   if (!taskWorkspaceRoot) return 'no task projection';
   if (!tasks.length) return 'empty task projection';
@@ -159,10 +161,11 @@ function shellQuote(value) {
   return `'${String(value || '').replace(/'/g, "'\\''")}'`;
 }
 
-function untaskedAction(agent, taskWorkspaceRoot, tasks) {
-  const reason = untaskedReason(agent, taskWorkspaceRoot, tasks);
+function untaskedAction(agent, taskWorkspaceRoot, tasks, binding = null) {
+  const reason = untaskedReason(agent, taskWorkspaceRoot, tasks, binding);
   const pid = agent.pid || '?';
   const actor = agent.agent || 'agent';
+  if (reason === 'interactive session') return `inspect pid ${pid} interactive claude session; bind via member lock, worktree sidecar, or branch identity before assuming a repo task`;
   if (reason === 'cwd unknown') return `inspect pid ${pid} cwd with lsof`;
   if (reason === 'no active task') return `cd ${shellQuote(taskWorkspaceRoot)} && atris task next --as ${actor}`;
   if (reason === 'empty task projection') return `cd ${shellQuote(taskWorkspaceRoot)} && atris task new "<small concrete title>" --tag ops`;
@@ -410,6 +413,213 @@ function taskRef(task) {
   return task ? (task.display_id || task.legacy_ref || task.id || '-') : '-';
 }
 
+function isInteractiveClaudeCommand(command) {
+  const cmd = String(command || '');
+  if (!/(^|\s|\/)claude(\s|$)/.test(cmd) || /Claude\.app/.test(cmd)) return false;
+  return !/(^|\s)-p(\s|$)/.test(cmd) && !/(^|\s)--print(\s|$)/.test(cmd);
+}
+
+function parseSessionIdFromCommand(command) {
+  const parts = String(command || '').split(/\s+/);
+  for (let i = 0; i < parts.length; i += 1) {
+    if ((parts[i] === '--session-id' || parts[i] === '--resume') && parts[i + 1]) return parts[i + 1];
+    const inline = parts[i].match(/^--session-id=(.+)$/);
+    if (inline) return inline[1];
+  }
+  return null;
+}
+
+function loadAgentWorktreeSidecar(cwd, deps) {
+  if (!cwd) return null;
+  let current = path.resolve(cwd);
+  for (let depth = 0; depth < 8; depth += 1) {
+    const payload = readJsonFile(path.join(current, '.atris', 'agent-worktree.json'), deps, null);
+    if (payload) return payload;
+    const parent = path.dirname(current);
+    if (!parent || parent === current) break;
+    current = parent;
+  }
+  return null;
+}
+
+function branchIdentityAtCwd(cwd, execFile) {
+  if (!cwd) return null;
+  try {
+    const branch = String(execFile('git', ['-C', cwd, 'branch', '--show-current'], { encoding: 'utf8', stdio: ['pipe', 'pipe', 'ignore'] })).trim();
+    if (!branch) return null;
+    const owner = String(execFile('git', ['-C', cwd, 'config', '--get', `branch.${branch}.atris-owner`], { encoding: 'utf8', stdio: ['pipe', 'pipe', 'ignore'] })).trim();
+    const taskHint = String(execFile('git', ['-C', cwd, 'config', '--get', `branch.${branch}.atris-task`], { encoding: 'utf8', stdio: ['pipe', 'pipe', 'ignore'] })).trim();
+    if (!owner) return null;
+    return { owner, task_hint: taskHint || null, branch };
+  } catch {
+    return null;
+  }
+}
+
+function loadMissionLocks(stateDir, deps) {
+  const locks = [];
+  for (const name of listNames(stateDir, deps)) {
+    const match = name.match(/^mission-(.+)\.lock$/);
+    if (!match) continue;
+    const payload = readJsonFile(path.join(stateDir, name), deps, null);
+    if (!payload || payload.pid == null) continue;
+    locks.push({
+      ...payload,
+      mission_id: payload.mission_id || match[1],
+      lock_file: name,
+    });
+  }
+  return locks;
+}
+
+function loadMemberLoopLocks(stateDir, deps) {
+  const dir = path.join(stateDir, 'member-loops');
+  const locks = [];
+  for (const name of listNames(dir, deps)) {
+    if (!name.endsWith('.lock.json')) continue;
+    const payload = readJsonFile(path.join(dir, name), deps, null);
+    if (!payload || payload.pid == null) continue;
+    locks.push({
+      ...payload,
+      member: payload.member || name.replace(/\.lock\.json$/, ''),
+    });
+  }
+  return locks;
+}
+
+function loadWorkspaceIdentity(root, deps, cache, nowMs) {
+  if (!root) return { missions: [], missionLocks: [], memberLocks: [] };
+  if (cache.has(root)) return cache.get(root);
+  const stateDir = path.join(root, '.atris', 'state');
+  const bundle = {
+    missions: loadMissions(root, deps, nowMs),
+    missionLocks: loadMissionLocks(stateDir, deps),
+    memberLocks: loadMemberLoopLocks(stateDir, deps),
+  };
+  cache.set(root, bundle);
+  return bundle;
+}
+
+function taskOwnerValues(task) {
+  return [
+    task?.assigned_to,
+    task?.claimed_by,
+    task?.metadata?.assigned_to,
+    task?.metadata?.claimed_by,
+    task?.metadata?.owner,
+  ].filter(Boolean).map(value => String(value));
+}
+
+function taskMatchesOwner(task, owner) {
+  if (!task || !owner) return false;
+  const want = String(owner).toLowerCase();
+  return taskOwnerValues(task).some(value => value.toLowerCase() === want);
+}
+
+function findTaskByRef(tasks, ref) {
+  if (!ref) return null;
+  return tasks.find(task => taskRef(task) === ref) || null;
+}
+
+function taskForOwner(tasks, owner, statuses = ['claimed', 'open', 'review']) {
+  if (!owner) return null;
+  for (const status of statuses) {
+    const matches = tasks.filter(task => task.status === status && taskMatchesOwner(task, owner));
+    if (matches.length === 1) return matches[0];
+    if (matches.length > 1) return matches[0];
+  }
+  return null;
+}
+
+function resolveAgentTaskBinding(context) {
+  const {
+    agent,
+    tasks,
+    missions,
+    missionLocks,
+    memberLocks,
+    sidecar,
+    branchIdentity,
+    sessionId,
+    interactive,
+    taskWorkspaceRoot,
+  } = context;
+  const pid = String(agent?.pid || '');
+
+  const missionLock = missionLocks.find(row => String(row.pid) === pid);
+  if (missionLock) {
+    const mission = missions.find(row => row.id === missionLock.mission_id);
+    const task = findTaskByRef(tasks, mission?.task_spine?.task_ref) || taskForOwner(tasks, mission?.owner);
+    return {
+      task,
+      owner: mission?.owner || ownerForTask(task),
+      member: mission?.owner || sidecar?.member || null,
+      session_id: mission?.claude_session_id || sessionId || null,
+      mission_id: mission?.id || missionLock.mission_id,
+      ...taskBinding('mission_lock', 'process'),
+    };
+  }
+
+  const memberLock = memberLocks.find(row => String(row.pid) === pid);
+  if (memberLock) {
+    const task = taskForOwner(tasks, memberLock.member);
+    return {
+      task,
+      owner: memberLock.member,
+      member: memberLock.member,
+      session_id: sessionId || null,
+      ...taskBinding('member_loop_lock', 'process'),
+    };
+  }
+
+  if (sessionId) {
+    const mission = missions.find(row => row.claude_session_id === sessionId || row.pending_session_id === sessionId);
+    if (mission) {
+      const task = findTaskByRef(tasks, mission.task_spine?.task_ref) || taskForOwner(tasks, mission.owner);
+      return {
+        task,
+        owner: mission.owner || ownerForTask(task),
+        member: mission.owner || sidecar?.member || null,
+        session_id: sessionId,
+        mission_id: mission.id,
+        ...taskBinding('claude_session', 'process'),
+      };
+    }
+  }
+
+  const ownerHint = sidecar?.owner || sidecar?.member || branchIdentity?.owner || null;
+  if (ownerHint) {
+    const task = taskForOwner(tasks, ownerHint);
+    return {
+      task,
+      owner: ownerHint,
+      member: sidecar?.member || ownerHint,
+      session_id: sessionId || null,
+      ...taskBinding(sidecar ? 'agent_worktree' : 'branch_identity', 'process'),
+    };
+  }
+
+  if (interactive) {
+    return {
+      task: null,
+      owner: 'interactive',
+      member: null,
+      session_id: sessionId || null,
+      interactive: true,
+      ...taskBinding('interactive_session', 'process'),
+    };
+  }
+
+  const fallbackTask = taskForCwd(tasks, agent?.cwd, taskWorkspaceRoot, agent);
+  return {
+    task: fallbackTask,
+    owner: ownerForTask(fallbackTask),
+    member: null,
+    session_id: sessionId || null,
+    ...(fallbackTask ? taskBinding('repo_task_projection', 'repo') : taskBinding(null, null)),
+  };
+}
+
 function taskOwnerMatchesAgent(task, agent) {
   const actor = String(agent?.agent || '').toLowerCase();
   if (!actor) return false;
@@ -438,15 +648,22 @@ function taskForCwd(tasks, cwd, workspaceRoot = cwd, agent = null) {
     || null;
 }
 
+function taskBinding(source, scope = null) {
+  if (!source) return { task_source: null, task_scope: null };
+  return { task_source: source, task_scope: scope };
+}
+
 function taskBindingForProjection(task) {
-  if (!task) return { task_source: null, task_scope: null };
-  return {
-    task_source: 'repo_task_projection',
-    task_scope: 'repo',
-  };
+  return task ? taskBinding('repo_task_projection', 'repo') : taskBinding(null, null);
 }
 
 function taskSourceLabel(sources = []) {
+  if (sources.includes('member_loop_lock')) return 'member loop lock';
+  if (sources.includes('mission_lock')) return 'mission lock';
+  if (sources.includes('claude_session')) return 'claude session id';
+  if (sources.includes('agent_worktree')) return 'agent worktree sidecar';
+  if (sources.includes('branch_identity')) return 'branch identity';
+  if (sources.includes('interactive_session')) return 'interactive session';
   if (sources.includes('repo_task_projection')) return 'repo projection; verify ownership';
   return sources.filter(Boolean).join(', ');
 }
@@ -556,23 +773,45 @@ function collectRadar(options = {}) {
   const nowMs = options.nowMs || Date.now();
   const tasks = loadTasks(root, deps);
   const taskCache = new Map([[root, tasks]]);
+  const identityCache = new Map();
   const missions = loadMissions(root, deps, nowMs);
+  identityCache.set(root, { missions, missionLocks: loadMissionLocks(path.join(root, '.atris', 'state'), deps), memberLocks: loadMemberLoopLocks(path.join(root, '.atris', 'state'), deps) });
   const worktrees = loadWorktrees(root, deps);
   const agents = collectAgents(deps).map(agent => {
     const taskWorkspaceRoot = findTaskWorkspaceRoot(agent.cwd, deps);
     const agentTasks = taskWorkspaceRoot ? loadTasksCached(taskWorkspaceRoot, deps, taskCache) : [];
-    const task = taskForCwd(agentTasks, agent.cwd, taskWorkspaceRoot, agent);
-    const taskReason = task ? taskSessionReason(task) : untaskedReason(agent, taskWorkspaceRoot, agentTasks);
-    const taskBinding = taskBindingForProjection(task);
+    const identity = taskWorkspaceRoot ? loadWorkspaceIdentity(taskWorkspaceRoot, deps, identityCache, nowMs) : { missions: [], missionLocks: [], memberLocks: [] };
+    const sidecar = loadAgentWorktreeSidecar(agent.cwd, deps);
+    const branchIdentity = branchIdentityAtCwd(agent.cwd, deps.execFile);
+    const sessionId = parseSessionIdFromCommand(agent.command);
+    const interactive = agent.agent === 'claude' && isInteractiveClaudeCommand(agent.command);
+    const resolved = resolveAgentTaskBinding({
+      agent,
+      tasks: agentTasks,
+      missions: identity.missions,
+      missionLocks: identity.missionLocks,
+      memberLocks: identity.memberLocks,
+      sidecar,
+      branchIdentity,
+      sessionId,
+      interactive,
+      taskWorkspaceRoot,
+    });
+    const task = resolved.task;
+    const taskReason = task ? taskSessionReason(task) : untaskedReason(agent, taskWorkspaceRoot, agentTasks, resolved);
+    const binding = { task_source: resolved.task_source, task_scope: resolved.task_scope };
     return {
       ...agent,
       task: taskRef(task),
       task_status: task?.status || null,
-      owner: ownerForTask(task),
+      owner: resolved.owner || ownerForTask(task),
+      member: resolved.member || null,
+      session_id: resolved.session_id || null,
+      mission_id: resolved.mission_id || null,
       task_workspace: taskWorkspaceRoot ? repoLabel(taskWorkspaceRoot) : null,
-      ...taskBinding,
+      ...binding,
       task_reason: taskReason,
-      task_action: task ? taskSessionAction(agent, task, taskWorkspaceRoot) : untaskedAction(agent, taskWorkspaceRoot, agentTasks),
+      task_action: task ? taskSessionAction(agent, task, taskWorkspaceRoot) : untaskedAction(agent, taskWorkspaceRoot, agentTasks, resolved),
     };
   });
   const osState = {
@@ -949,10 +1188,16 @@ function radarCommand(args = [], options = {}) {
 module.exports = {
   agentTypeForCommand,
   agentTopPayload,
+  branchIdentityAtCwd,
   collectRadar,
+  isInteractiveClaudeCommand,
+  loadAgentWorktreeSidecar,
   parsePsOutput,
+  parseSessionIdFromCommand,
   parseWorktrees,
   radarCommand,
   renderAgentTop,
   renderRadar,
+  resolveAgentTaskBinding,
+  taskForOwner,
 };

package/commands/serve.js

@@ -208,8 +208,39 @@ function streamSession(token, sessionId, workingDir) {
 
       console.log(`● Bridge active — listening for ops on session ${sessionId.slice(0, 8)}...`);
 
+      // Ping watchdog: the server pings every ~30s. Silence past 3 intervals
+      // means the socket died without a FIN (server redeploy, NAT drop) —
+      // kill it so the outer loop reconnects/re-registers instead of zombieing.
+      let lastSeen = Date.now();
+      const watchdog = setInterval(() => {
+        if (Date.now() - lastSeen > HEARTBEAT_INTERVAL_MS * 3) {
+          clearInterval(watchdog);
+          res.destroy(new Error('stream silent >90s, assuming dead socket'));
+        }
+      }, HEARTBEAT_INTERVAL_MS);
+      res.on('close', () => clearInterval(watchdog));
+
+      // Registry check: a rolling deploy can leave this stream alive on an
+      // old instance while new instances answer API calls from an empty
+      // in-memory session store — pings keep flowing so the silence watchdog
+      // never fires, but dispatchers can't find us. Ask the registry
+      // directly; if it forgot this session, reconnect and re-register.
+      const registryCheck = setInterval(async () => {
+        try {
+          const result = await apiRequestJson('/cli/sessions', { method: 'GET', token });
+          if (!result.ok) return; // transient API errors don't kill a live stream
+          const sessions = (result.data && result.data.sessions) || [];
+          if (!sessions.some((s) => s.id === sessionId)) {
+            clearInterval(registryCheck);
+            res.destroy(new Error('session missing from server registry, re-registering'));
+          }
+        } catch { /* network blips are the silence watchdog's job */ }
+      }, HEARTBEAT_INTERVAL_MS * 4);
+      res.on('close', () => clearInterval(registryCheck));
+
       let buffer = '';
       res.on('data', async (chunk) => {
+        lastSeen = Date.now();
         buffer += chunk.toString();
         const messages = buffer.split('\n\n');
         buffer = messages.pop() || '';
@@ -345,6 +376,29 @@ async function serveAtris(options = {}) {
       reconnectDelay = RECONNECT_DELAY_MS; // reset on clean disconnect
     } catch (err) {
       if (shuttingDown) break;
+      // Server restarts wipe the in-memory session store — a dead session id
+      // 404s forever, so re-register instead of retrying the corpse.
+      if (/session not found|404/i.test(err.message || '')) {
+        try {
+          const result = await apiRequestJson('/cli/sessions', {
+            method: 'POST',
+            token,
+            body: {
+              working_directory: workingDir,
+              agent_id: agentId,
+              allow_bash: allowBash,
+            },
+          });
+          if (result.ok && result.data && result.data.session_id) {
+            session = result.data;
+            console.log(`  ✓ Session expired server-side — re-registered as ${session.session_id}`);
+            reconnectDelay = RECONNECT_DELAY_MS;
+            continue;
+          }
+        } catch {
+          // fall through to normal backoff
+        }
+      }
       console.error(`  ⚠ Stream error: ${err.message}, reconnecting in ${reconnectDelay / 1000}s...`);
       await new Promise((r) => setTimeout(r, reconnectDelay));
       reconnectDelay = Math.min(reconnectDelay * 2, MAX_RECONNECT_DELAY_MS);

package/commands/status.js

@@ -2,6 +2,7 @@ const fs = require('fs');
 const path = require('path');
 const { getLogPath, ensureLogDirectory, createLogFile } = require('../lib/journal');
 const { parseTodo, getTeamActivity } = require('../lib/todo');
+const { clarify } = require('../lib/autoland');
 
 // Box drawing helpers
 const W = 64; // inner width
@@ -76,6 +77,50 @@ function readEndgameMeta(todoFile) {
   return { slug, horizon };
 }
 
+function todoItemFromTaskRow(row) {
+  const metadata = row.metadata && typeof row.metadata === 'object' ? row.metadata : {};
+  return {
+    id: row.display_id || row.id,
+    title: row.title,
+    tag: row.tag || null,
+    tags: row.tag ? [row.tag] : [],
+    claimed: row.claimed_by || metadata.claimed || null,
+    stage: row.status === 'claimed' ? 'in_progress' : (metadata.stage || null),
+    verify: typeof metadata.verify === 'string' && metadata.verify.trim()
+      ? metadata.verify.trim()
+      : null,
+    _source: 'db',
+  };
+}
+
+function parseStatusTodo(todoFile) {
+  try {
+    const taskDb = require('../lib/task-db');
+    const { DatabaseSync } = require('node:sqlite');
+    const dbPath = taskDb.getDbPath();
+    if (!dbPath || !fs.existsSync(dbPath)) return parseTodo(todoFile);
+    const db = new DatabaseSync(dbPath, { readOnly: true });
+    try {
+      const workspaceRoot = taskDb.workspaceRoot();
+      const rows = taskDb.withTaskDisplayRefs(taskDb.listTasks(db, { workspaceRoot, limit: 500 }));
+      const todo = { backlog: [], inProgress: [], review: [], completed: [] };
+      for (const row of rows) {
+        const item = todoItemFromTaskRow(row);
+        if (row.status === 'open') todo.backlog.push(item);
+        else if (row.status === 'claimed') todo.inProgress.push(item);
+        else if (row.status === 'review') todo.review.push(item);
+        else if (row.status === 'done') todo.completed.push(item);
+      }
+      return todo;
+    } finally {
+      db.close();
+    }
+  } catch (e) {
+    if (process.env.ATRIS_DEBUG) console.error('[status] task db read failed:', e.message);
+    return parseTodo(todoFile);
+  }
+}
+
 function statusAtris(isQuick = false, jsonMode = false, verbose = false) {
   const targetDir = path.join(process.cwd(), 'atris');
 
@@ -88,9 +133,9 @@ function statusAtris(isQuick = false, jsonMode = false, verbose = false) {
     process.exit(1);
   }
 
-  // Parse TODO.md
+  // Load task board state.
   const todoFile = path.join(targetDir, 'TODO.md');
-  const todo = parseTodo(todoFile);
+  const todo = parseStatusTodo(todoFile);
 
   // Read journal for inbox and completions
   const { logFile, dateFormatted } = getLogPath();
@@ -184,7 +229,7 @@ function statusAtris(isQuick = false, jsonMode = false, verbose = false) {
     if (endgame.slug) {
       where.push(`The active horizon is ${endgame.slug}.`);
       if (endgame.horizon) {
-        where.push(...compactWrappedText(endgame.horizon, 74, 2));
+        where.push(...compactWrappedText(clarify(endgame.horizon), 74, 2));
       }
     } else {
       where.push('No active endgame is set.');
@@ -198,12 +243,12 @@ function statusAtris(isQuick = false, jsonMode = false, verbose = false) {
 
     const queueParts = [];
     if (todo.inProgress[0]) {
-      queueParts.push(...compactWrappedText(`In progress: ${todo.inProgress[0].title}.`, 74, 2));
+      queueParts.push(...compactWrappedText(`In progress: ${clarify(todo.inProgress[0].title)}.`, 74, 2));
     } else {
       queueParts.push('In progress: none.');
     }
     if (todo.backlog[0]) {
-      queueParts.push(...compactWrappedText(`Next backlog item: ${todo.backlog[0].title}.`, 74, 2));
+      queueParts.push(...compactWrappedText(`Next backlog item: ${clarify(todo.backlog[0].title)}.`, 74, 2));
     } else {
       queueParts.push('Next backlog item: none.');
     }

package/commands/stripe.js

@@ -0,0 +1,38 @@
+const { createOfficialCliCommand } = require('../lib/official-cli-integration');
+
+const stripeCommand = createOfficialCliCommand({
+  name: 'stripe',
+  binary: 'stripe',
+  versionArgs: ['--version'],
+  authArgs: ['config', '--list'],
+  installHint: 'https://docs.stripe.com/stripe-cli',
+  loginHint: 'stripe login',
+  commands: [
+    {
+      usage: 'listen',
+      match: ['listen'],
+      forward: ['listen'],
+      description: 'listen for webhook events',
+    },
+    {
+      usage: 'trigger',
+      match: ['trigger'],
+      forward: ['trigger'],
+      description: 'trigger test webhook events',
+    },
+    {
+      usage: 'products list',
+      match: ['products', 'list'],
+      forward: ['products', 'list'],
+      description: 'list products',
+    },
+    {
+      usage: 'products create',
+      match: ['products', 'create'],
+      forward: ['products', 'create'],
+      description: 'create a product',
+    },
+  ],
+});
+
+module.exports = { stripeCommand };

package/commands/supabase.js

@@ -0,0 +1,39 @@
+const { createOfficialCliCommand } = require('../lib/official-cli-integration');
+
+const supabaseCommand = createOfficialCliCommand({
+  name: 'supabase',
+  binary: 'supabase',
+  versionArgs: ['--version'],
+  authArgs: ['projects', 'list'],
+  doctorAliases: ['doctor'],
+  installHint: 'https://supabase.com/docs/guides/cli',
+  loginHint: 'supabase login',
+  commands: [
+    {
+      usage: 'status',
+      match: ['status'],
+      forward: ['status'],
+      description: 'show local project status',
+    },
+    {
+      usage: 'db push',
+      match: ['db', 'push'],
+      forward: ['db', 'push'],
+      description: 'push local database migrations',
+    },
+    {
+      usage: 'functions list',
+      match: ['functions', 'list'],
+      forward: ['functions', 'list'],
+      description: 'list edge functions',
+    },
+    {
+      usage: 'functions deploy',
+      match: ['functions', 'deploy'],
+      forward: ['functions', 'deploy'],
+      description: 'deploy an edge function',
+    },
+  ],
+});
+
+module.exports = { supabaseCommand };