purplemux 0.2.2 → 0.2.4

package/.next/standalone/src/pages/api/layout/diff.ts

@@ -0,0 +1,196 @@
+import type { NextApiRequest, NextApiResponse } from 'next';
+import { execFile as execFileCb } from 'child_process';
+import { createHash } from 'crypto';
+import { promisify } from 'util';
+import { getSessionCwd, hasSession } from '@/lib/tmux';
+import { createLogger } from '@/lib/logger';
+
+const execFile = promisify(execFileCb);
+const log = createLogger('diff');
+const CMD_TIMEOUT = 10000;
+const FETCH_TIMEOUT = 20000;
+
+const getAheadBehind = async (cwd: string): Promise<{ ahead: number; behind: number }> => {
+  try {
+    const { stdout } = await execFile(
+      'git',
+      ['rev-list', '--left-right', '--count', 'HEAD...@{upstream}'],
+      { cwd, timeout: CMD_TIMEOUT },
+    );
+    const parts = stdout.trim().split(/\s+/);
+    return {
+      ahead: parseInt(parts[0], 10) || 0,
+      behind: parseInt(parts[1], 10) || 0,
+    };
+  } catch {
+    return { ahead: 0, behind: 0 };
+  }
+};
+
+interface IHeadCommit {
+  hash: string;
+  shortHash: string;
+  subject: string;
+  author: string;
+  timestamp: number;
+}
+
+interface IRepoMeta {
+  branch: string;
+  upstream: string | null;
+  isDetached: boolean;
+  stash: number;
+  headCommit: IHeadCommit | null;
+}
+
+const FIELD = '\x1f';
+
+const getRepoMeta = async (cwd: string): Promise<IRepoMeta> => {
+  const [branchRes, upstreamRes, stashRes, headRes] = await Promise.allSettled([
+    execFile('git', ['rev-parse', '--abbrev-ref', 'HEAD'], { cwd, timeout: CMD_TIMEOUT }),
+    execFile('git', ['rev-parse', '--abbrev-ref', '--symbolic-full-name', '@{upstream}'], { cwd, timeout: CMD_TIMEOUT }),
+    execFile('git', ['stash', 'list'], { cwd, timeout: CMD_TIMEOUT }),
+    execFile('git', ['log', '-1', `--format=%H${FIELD}%s${FIELD}%an${FIELD}%at`], { cwd, timeout: CMD_TIMEOUT }),
+  ]);
+
+  const branch = branchRes.status === 'fulfilled' ? branchRes.value.stdout.trim() : '';
+  const upstream = upstreamRes.status === 'fulfilled' ? upstreamRes.value.stdout.trim() : null;
+  const stashOut = stashRes.status === 'fulfilled' ? stashRes.value.stdout.trim() : '';
+  const stash = stashOut ? stashOut.split('\n').length : 0;
+
+  let headCommit: IHeadCommit | null = null;
+  if (headRes.status === 'fulfilled') {
+    const parts = headRes.value.stdout.trim().split(FIELD);
+    if (parts.length >= 4) {
+      const [hash, subject, author, ts] = parts;
+      headCommit = {
+        hash,
+        shortHash: hash.slice(0, 7),
+        subject,
+        author,
+        timestamp: parseInt(ts, 10) * 1000,
+      };
+    }
+  }
+
+  return {
+    branch,
+    upstream,
+    isDetached: branch === 'HEAD',
+    stash,
+    headCommit,
+  };
+};
+
+const computeDiffHash = async (cwd: string) => {
+  const [{ stdout: headOut }, { stdout: statusOut }, { stdout: shortstatOut }] = await Promise.all([
+    execFile('git', ['rev-parse', 'HEAD'], { cwd, timeout: CMD_TIMEOUT }),
+    execFile('git', ['status', '--porcelain', '-uall'], { cwd, timeout: CMD_TIMEOUT }),
+    execFile('git', ['diff', 'HEAD', '--shortstat'], { cwd, timeout: CMD_TIMEOUT }),
+  ]);
+  return createHash('sha1')
+    .update(`${headOut.trim()}\n${statusOut}\n${shortstatOut}`)
+    .digest('hex')
+    .slice(0, 16);
+};
+
+const handler = async (req: NextApiRequest, res: NextApiResponse) => {
+  if (req.method !== 'GET') {
+    res.setHeader('Allow', 'GET');
+    return res.status(405).json({ error: 'Method not allowed' });
+  }
+
+  const session = req.query.session as string | undefined;
+  const hashOnly = req.query.hashOnly === 'true';
+  const doFetch = req.query.fetch === 'true';
+
+  if (!session) {
+    return res.status(400).json({ error: 'session parameter required' });
+  }
+
+  const exists = await hasSession(session);
+  if (!exists) {
+    return res.status(404).json({ error: 'Session not found' });
+  }
+
+  const cwd = await getSessionCwd(session);
+  if (!cwd) {
+    return res.status(500).json({ error: 'Failed to get CWD' });
+  }
+
+  try {
+    await execFile('git', ['rev-parse', '--is-inside-work-tree'], { cwd, timeout: CMD_TIMEOUT });
+  } catch {
+    return res.status(200).json({ isGitRepo: false, diff: '', hash: '' });
+  }
+
+  let fetched = false;
+  if (doFetch) {
+    try {
+      await execFile('git', ['fetch', '--prune'], { cwd, timeout: FETCH_TIMEOUT });
+      fetched = true;
+    } catch (err) {
+      log.warn(`silent fetch failed: ${err instanceof Error ? err.message : err}`);
+    }
+  }
+
+  try {
+    if (hashOnly) {
+      const [hash, aheadBehind] = await Promise.all([
+        computeDiffHash(cwd),
+        getAheadBehind(cwd),
+      ]);
+      return res.status(200).json({
+        isGitRepo: true,
+        hash,
+        ahead: aheadBehind.ahead,
+        behind: aheadBehind.behind,
+        fetched,
+      });
+    }
+
+    const [{ stdout: diff }, { stdout: statusOut }, hash, aheadBehind, meta] = await Promise.all([
+      execFile('git', ['diff', 'HEAD'], { cwd, timeout: CMD_TIMEOUT, maxBuffer: 5 * 1024 * 1024 }),
+      execFile('git', ['status', '--porcelain', '-uall'], { cwd, timeout: CMD_TIMEOUT }),
+      computeDiffHash(cwd),
+      getAheadBehind(cwd),
+      getRepoMeta(cwd),
+    ]);
+
+    const untrackedFiles = statusOut
+      .split('\n')
+      .filter((line) => line.startsWith('??'))
+      .map((line) => line.slice(3).trim());
+
+    let fullDiff = diff;
+    for (const file of untrackedFiles) {
+      try {
+        const { stdout: fileDiff } = await execFile('git', ['diff', '--no-index', '/dev/null', file], { cwd, timeout: CMD_TIMEOUT });
+        fullDiff += fileDiff;
+      } catch (err: unknown) {
+        if (err && typeof err === 'object' && 'stdout' in err) {
+          fullDiff += (err as { stdout: string }).stdout;
+        }
+      }
+    }
+
+    return res.status(200).json({
+      isGitRepo: true,
+      diff: fullDiff,
+      hash,
+      ahead: aheadBehind.ahead,
+      behind: aheadBehind.behind,
+      branch: meta.branch,
+      upstream: meta.upstream,
+      isDetached: meta.isDetached,
+      stash: meta.stash,
+      headCommit: meta.headCommit,
+      fetched,
+    });
+  } catch (err) {
+    log.error(`git diff failed: ${err instanceof Error ? err.message : err}`);
+    return res.status(500).json({ error: 'Failed to get diff' });
+  }
+};
+
+export default handler;

package/.next/standalone/src/pages/api/layout/file-content.ts

@@ -0,0 +1,130 @@
+import type { NextApiRequest, NextApiResponse } from 'next';
+import { execFile as execFileCb } from 'child_process';
+import { promisify } from 'util';
+import { readFile } from 'fs/promises';
+import { resolve, sep } from 'path';
+import { getSessionCwd, hasSession } from '@/lib/tmux';
+import { createLogger } from '@/lib/logger';
+
+const execFile = promisify(execFileCb);
+const log = createLogger('file-content');
+
+const CMD_TIMEOUT = 10_000;
+const MAX_BYTES = 1_000_000;
+const WORKTREE = 'WORKTREE';
+const REF_RE = /^[A-Za-z0-9][A-Za-z0-9_\-/.^~]{0,200}$/;
+
+interface ISideResult {
+  content: string;
+  truncated: boolean;
+  binary: boolean;
+}
+
+const EMPTY_SIDE: ISideResult = { content: '', truncated: false, binary: false };
+
+const sanitizeRepoPath = (p: string | undefined | string[]): string | null => {
+  if (!p || Array.isArray(p)) return null;
+  if (p === '/dev/null') return null;
+  if (p.includes('\0')) return null;
+  if (p.startsWith('/')) return null;
+
+  let depth = 0;
+  for (const part of p.split('/')) {
+    if (part === '' || part === '.') continue;
+    if (part === '..') {
+      depth -= 1;
+      if (depth < 0) return null;
+    } else {
+      depth += 1;
+    }
+  }
+  return p;
+};
+
+const sanitizeRef = (r: string | string[] | undefined, fallback: string): string | null => {
+  const v = Array.isArray(r) ? r[0] : r;
+  if (!v) return fallback;
+  if (v === WORKTREE) return WORKTREE;
+  if (!REF_RE.test(v)) return null;
+  return v;
+};
+
+const fromBuffer = (buf: Buffer): ISideResult => {
+  if (buf.length > MAX_BYTES) return { content: '', truncated: true, binary: false };
+  if (buf.includes(0)) return { content: '', truncated: false, binary: true };
+  return { content: buf.toString('utf8'), truncated: false, binary: false };
+};
+
+const readFromRef = async (cwd: string, ref: string, relPath: string): Promise<ISideResult> => {
+  try {
+    const { stdout } = await execFile(
+      'git',
+      ['-C', cwd, 'show', `${ref}:${relPath}`],
+      { timeout: CMD_TIMEOUT, maxBuffer: MAX_BYTES + 1024, encoding: 'buffer' },
+    );
+    return fromBuffer(stdout as unknown as Buffer);
+  } catch {
+    return EMPTY_SIDE;
+  }
+};
+
+const readFromWorktree = async (cwd: string, relPath: string): Promise<ISideResult> => {
+  try {
+    const resolved = resolve(cwd, relPath);
+    if (resolved !== cwd && !resolved.startsWith(cwd + sep)) return EMPTY_SIDE;
+    const buf = await readFile(resolved);
+    return fromBuffer(buf);
+  } catch {
+    return EMPTY_SIDE;
+  }
+};
+
+const loadSide = (cwd: string, ref: string, relPath: string | null): Promise<ISideResult> => {
+  if (!relPath) return Promise.resolve(EMPTY_SIDE);
+  return ref === WORKTREE ? readFromWorktree(cwd, relPath) : readFromRef(cwd, ref, relPath);
+};
+
+const handler = async (req: NextApiRequest, res: NextApiResponse) => {
+  if (req.method !== 'GET') {
+    res.setHeader('Allow', 'GET');
+    return res.status(405).json({ error: 'Method not allowed' });
+  }
+
+  const session = typeof req.query.session === 'string' ? req.query.session : undefined;
+  if (!session) return res.status(400).json({ error: 'session parameter required' });
+
+  const oldPath = sanitizeRepoPath(req.query.oldPath);
+  const newPath = sanitizeRepoPath(req.query.newPath);
+  const oldRef = sanitizeRef(req.query.oldRef, 'HEAD');
+  const newRef = sanitizeRef(req.query.newRef, WORKTREE);
+
+  if (!oldRef || !newRef) return res.status(400).json({ error: 'Invalid ref' });
+  if (!oldPath && !newPath) return res.status(400).json({ error: 'oldPath or newPath required' });
+
+  if (!(await hasSession(session))) return res.status(404).json({ error: 'Session not found' });
+
+  const cwd = await getSessionCwd(session);
+  if (!cwd) return res.status(500).json({ error: 'Failed to get CWD' });
+
+  try {
+    const [oldSide, newSide] = await Promise.all([
+      loadSide(cwd, oldRef, oldPath),
+      loadSide(cwd, newRef, newPath),
+    ]);
+
+    const truncated = oldSide.truncated || newSide.truncated;
+    const binary = oldSide.binary || newSide.binary;
+
+    return res.status(200).json({
+      oldContent: truncated || binary ? '' : oldSide.content,
+      newContent: truncated || binary ? '' : newSide.content,
+      truncated,
+      binary,
+    });
+  } catch (err) {
+    log.error(`file-content failed: ${err instanceof Error ? err.message : err}`);
+    return res.status(500).json({ error: 'Failed to get file content' });
+  }
+};
+
+export default handler;

package/.next/standalone/src/pages/api/layout/git-log.ts

@@ -0,0 +1,55 @@
+import type { NextApiRequest, NextApiResponse } from 'next';
+import { execFile as execFileCb } from 'child_process';
+import { promisify } from 'util';
+import { getSessionCwd, hasSession } from '@/lib/tmux';
+import { getCommitLog } from '@/lib/git-log';
+import { createLogger } from '@/lib/logger';
+
+const execFile = promisify(execFileCb);
+const log = createLogger('git-log');
+const CMD_TIMEOUT = 5000;
+const DEFAULT_LIMIT = 50;
+const MAX_LIMIT = 500;
+
+const handler = async (req: NextApiRequest, res: NextApiResponse) => {
+  if (req.method !== 'GET') {
+    res.setHeader('Allow', 'GET');
+    return res.status(405).json({ error: 'Method not allowed' });
+  }
+
+  const session = req.query.session as string | undefined;
+  const limitParam = parseInt(req.query.limit as string, 10);
+  const limit = Math.min(Number.isFinite(limitParam) && limitParam > 0 ? limitParam : DEFAULT_LIMIT, MAX_LIMIT);
+  const skipParam = parseInt(req.query.skip as string, 10);
+  const skip = Number.isFinite(skipParam) && skipParam > 0 ? skipParam : 0;
+
+  if (!session) {
+    return res.status(400).json({ error: 'session parameter required' });
+  }
+
+  const exists = await hasSession(session);
+  if (!exists) {
+    return res.status(404).json({ error: 'Session not found' });
+  }
+
+  const cwd = await getSessionCwd(session);
+  if (!cwd) {
+    return res.status(500).json({ error: 'Failed to get CWD' });
+  }
+
+  try {
+    await execFile('git', ['-C', cwd, 'rev-parse', '--is-inside-work-tree'], { timeout: CMD_TIMEOUT });
+  } catch {
+    return res.status(200).json({ isGitRepo: false, commits: [] });
+  }
+
+  try {
+    const result = await getCommitLog(cwd, limit, skip);
+    return res.status(200).json({ isGitRepo: true, ...result });
+  } catch (err) {
+    log.error(`git log failed: ${err instanceof Error ? err.message : err}`);
+    return res.status(500).json({ error: 'Failed to get commit log' });
+  }
+};
+
+export default handler;

package/.next/standalone/src/pages/api/layout/index.ts

@@ -0,0 +1,38 @@
+import type { NextApiRequest, NextApiResponse } from 'next';
+import { getLayout, patchLayout } from '@/lib/layout-store';
+import { getActiveWorkspaceId, getWorkspaceById } from '@/lib/workspace-store';
+import { createLogger } from '@/lib/logger';
+
+const log = createLogger('layout');
+
+const handler = async (req: NextApiRequest, res: NextApiResponse) => {
+  const wsId = (req.query.workspace as string) || await getActiveWorkspaceId();
+  if (!wsId) {
+    return res.status(400).json({ error: 'No workspace found' });
+  }
+
+  if (req.method === 'GET') {
+    try {
+      const ws = await getWorkspaceById(wsId);
+      const layout = await getLayout(wsId, ws?.directories[0]);
+      return res.status(200).json(layout);
+    } catch (err) {
+      log.error(`GET failed: ${err instanceof Error ? err.message : err}`);
+      return res.status(500).json({ error: 'Failed to load layout' });
+    }
+  }
+
+  if (req.method === 'PATCH') {
+    const { activePaneId, ratioUpdate, equalize } = req.body ?? {};
+    const result = await patchLayout(wsId, { activePaneId, ratioUpdate, equalize });
+    if (!result) {
+      return res.status(404).json({ error: 'Target not found' });
+    }
+    return res.status(200).json(result);
+  }
+
+  res.setHeader('Allow', 'GET, PATCH');
+  return res.status(405).json({ error: 'Method not allowed' });
+};
+
+export default handler;

package/.next/standalone/src/pages/api/layout/pane/[paneId]/index.ts

@@ -0,0 +1,38 @@
+import type { NextApiRequest, NextApiResponse } from 'next';
+import { deletePane, patchPane, closePaneInLayout } from '@/lib/layout-store';
+import { getActiveWorkspaceId } from '@/lib/workspace-store';
+
+const handler = async (req: NextApiRequest, res: NextApiResponse) => {
+  const wsId = (req.query.workspace as string) || await getActiveWorkspaceId();
+  const paneId = req.query.paneId as string;
+
+  if (req.method === 'DELETE') {
+    if (!wsId) {
+      const sessions: string[] = req.body?.sessions ?? [];
+      await deletePane(paneId, sessions);
+      return res.status(204).end();
+    }
+    const result = await closePaneInLayout(wsId, paneId);
+    if (!result) {
+      return res.status(404).json({ error: 'Pane not found' });
+    }
+    return res.status(200).json(result);
+  }
+
+  if (req.method === 'PATCH') {
+    if (!wsId) {
+      return res.status(400).json({ error: 'No workspace found' });
+    }
+    const { activeTabId } = req.body ?? {};
+    const result = await patchPane(wsId, paneId, { activeTabId });
+    if (!result) {
+      return res.status(404).json({ error: 'Target not found' });
+    }
+    return res.status(200).json(result);
+  }
+
+  res.setHeader('Allow', 'DELETE, PATCH');
+  return res.status(405).json({ error: 'Method not allowed' });
+};
+
+export default handler;

package/.next/standalone/src/pages/api/layout/pane/[paneId]/tabs/[tabId]/index.ts

@@ -0,0 +1,94 @@
+import type { NextApiRequest, NextApiResponse } from 'next';
+import { removeTabFromPane, restartTabSession, patchTab } from '@/lib/layout-store';
+import { getActiveWorkspaceId } from '@/lib/workspace-store';
+import { getStatusManager } from '@/lib/status-manager';
+import { createLogger } from '@/lib/logger';
+import type { ITab } from '@/types/terminal';
+
+const log = createLogger('layout');
+
+const handler = async (req: NextApiRequest, res: NextApiResponse) => {
+  const wsId = (req.query.workspace as string) || await getActiveWorkspaceId();
+  if (!wsId) {
+    return res.status(400).json({ error: 'No workspace found' });
+  }
+
+  const paneId = req.query.paneId as string;
+  const tabId = req.query.tabId as string;
+
+  if (req.method === 'DELETE') {
+    const found = await removeTabFromPane(wsId, paneId, tabId);
+    if (!found) {
+      return res.status(404).json({ error: 'Tab not found' });
+    }
+    getStatusManager().removeTab(tabId);
+    return res.status(204).end();
+  }
+
+  if (req.method === 'POST') {
+    try {
+      const { command } = req.body ?? {};
+      const ok = await restartTabSession(wsId, paneId, tabId, command);
+      if (!ok) {
+        return res.status(404).json({ error: 'Tab not found' });
+      }
+      return res.status(200).json({ ok: true });
+    } catch (err) {
+      log.error(`tab restart failed: ${err instanceof Error ? err.message : err}`);
+      return res.status(500).json({ error: 'Failed to restart session' });
+    }
+  }
+
+  if (req.method === 'PATCH') {
+    const { name, panelType, title, cwd, lastCommand, webUrl, terminalRatio, terminalCollapsed } = req.body ?? {};
+
+    if (
+      name !== undefined ||
+      panelType !== undefined ||
+      title !== undefined ||
+      cwd !== undefined ||
+      lastCommand !== undefined ||
+      webUrl !== undefined ||
+      terminalRatio !== undefined ||
+      terminalCollapsed !== undefined
+    ) {
+      const patch: Partial<Pick<ITab, 'name' | 'panelType' | 'title' | 'cwd' | 'lastCommand' | 'webUrl' | 'terminalRatio' | 'terminalCollapsed'>> = {};
+      if (name !== undefined) {
+        if (typeof name !== 'string') {
+          return res.status(400).json({ error: 'name must be a string' });
+        }
+        patch.name = name.trim();
+      }
+      if (panelType !== undefined) patch.panelType = panelType;
+      if (title !== undefined) patch.title = title;
+      if (cwd !== undefined) patch.cwd = cwd;
+      if (lastCommand !== undefined) patch.lastCommand = lastCommand;
+      if (webUrl !== undefined) patch.webUrl = webUrl;
+      if (terminalRatio !== undefined) {
+        if (typeof terminalRatio !== 'number' || !Number.isFinite(terminalRatio)) {
+          return res.status(400).json({ error: 'terminalRatio must be a number' });
+        }
+        patch.terminalRatio = Math.max(0, Math.min(100, terminalRatio));
+      }
+      if (terminalCollapsed !== undefined) {
+        if (typeof terminalCollapsed !== 'boolean') {
+          return res.status(400).json({ error: 'terminalCollapsed must be a boolean' });
+        }
+        patch.terminalCollapsed = terminalCollapsed;
+      }
+
+      const result = await patchTab(wsId, paneId, tabId, patch);
+      if (!result) {
+        return res.status(404).json({ error: 'Tab not found' });
+      }
+      return res.status(200).json(result);
+    }
+
+    return res.status(400).json({ error: 'No fields to update' });
+  }
+
+  res.setHeader('Allow', 'POST, DELETE, PATCH');
+  return res.status(405).json({ error: 'Method not allowed' });
+};
+
+export default handler;

package/.next/standalone/src/pages/api/layout/pane/[paneId]/tabs/[tabId]/move.ts

@@ -0,0 +1,31 @@
+import type { NextApiRequest, NextApiResponse } from 'next';
+import { moveTabBetweenPanes } from '@/lib/layout-store';
+import { getActiveWorkspaceId } from '@/lib/workspace-store';
+
+const handler = async (req: NextApiRequest, res: NextApiResponse) => {
+  if (req.method !== 'POST') {
+    res.setHeader('Allow', 'POST');
+    return res.status(405).json({ error: 'Method not allowed' });
+  }
+
+  const wsId = (req.query.workspace as string) || await getActiveWorkspaceId();
+  if (!wsId) {
+    return res.status(400).json({ error: 'No workspace found' });
+  }
+
+  const tabId = req.query.tabId as string;
+  const fromPaneId = req.query.paneId as string;
+  const { toPaneId, toIndex } = req.body ?? {};
+
+  if (!toPaneId || toIndex === undefined) {
+    return res.status(400).json({ error: 'toPaneId and toIndex required' });
+  }
+
+  const result = await moveTabBetweenPanes(wsId, tabId, fromPaneId, toPaneId, toIndex);
+  if (!result) {
+    return res.status(404).json({ error: 'Target not found' });
+  }
+  return res.status(200).json(result);
+};
+
+export default handler;

package/.next/standalone/src/pages/api/layout/pane/[paneId]/tabs/index.ts

@@ -0,0 +1,66 @@
+import type { NextApiRequest, NextApiResponse } from 'next';
+import { addTabToPane, updateTabClaudeSessionId } from '@/lib/layout-store';
+import { getActiveWorkspaceId } from '@/lib/workspace-store';
+import { getStatusManager } from '@/lib/status-manager';
+import { buildResumeCommand, isValidSessionId } from '@/lib/claude-command';
+import { sendKeys } from '@/lib/tmux';
+import { createLogger } from '@/lib/logger';
+
+const log = createLogger('layout');
+
+const SHELL_READY_DELAY_MS = 500;
+
+const handler = async (req: NextApiRequest, res: NextApiResponse) => {
+  if (req.method !== 'POST') {
+    res.setHeader('Allow', 'POST');
+    return res.status(405).json({ error: 'Method not allowed' });
+  }
+
+  const wsId = (req.query.workspace as string) || await getActiveWorkspaceId();
+  if (!wsId) {
+    return res.status(400).json({ error: 'No workspace found' });
+  }
+
+  const paneId = req.query.paneId as string;
+  const { name, cwd, panelType, command, resumeSessionId } = req.body ?? {};
+  if (resumeSessionId && !isValidSessionId(resumeSessionId)) {
+    return res.status(400).json({ error: 'Invalid session ID format' });
+  }
+
+  try {
+    const tab = await addTabToPane(wsId, paneId, name, cwd, panelType, command);
+    if (!tab) {
+      return res.status(404).json({ error: 'Pane not found' });
+    }
+    if (tab.panelType !== 'web-browser') {
+      getStatusManager().registerTab(tab.id, {
+        cliState: 'inactive',
+        workspaceId: wsId,
+        tabName: tab.name,
+        tmuxSession: tab.sessionName,
+        lastEvent: null,
+        eventSeq: 0,
+      });
+    }
+
+    if (resumeSessionId && !command) {
+      await updateTabClaudeSessionId(tab.sessionName, resumeSessionId);
+      tab.claudeSessionId = resumeSessionId;
+      setTimeout(async () => {
+        try {
+          const resumeCmd = await buildResumeCommand(resumeSessionId, wsId);
+          await sendKeys(tab.sessionName, resumeCmd);
+        } catch (err) {
+          log.warn(`resume sendKeys failed: ${err instanceof Error ? err.message : err}`);
+        }
+      }, SHELL_READY_DELAY_MS);
+    }
+
+    return res.status(200).json(tab);
+  } catch (err) {
+    log.error(`tab creation failed: ${err instanceof Error ? err.message : err}`);
+    return res.status(500).json({ error: 'Failed to create tab' });
+  }
+};
+
+export default handler;

package/.next/standalone/src/pages/api/layout/pane/[paneId]/tabs/order.ts

@@ -0,0 +1,30 @@
+import type { NextApiRequest, NextApiResponse } from 'next';
+import { reorderTabsInPane } from '@/lib/layout-store';
+import { getActiveWorkspaceId } from '@/lib/workspace-store';
+
+const handler = async (req: NextApiRequest, res: NextApiResponse) => {
+  if (req.method !== 'PATCH') {
+    res.setHeader('Allow', 'PATCH');
+    return res.status(405).json({ error: 'Method not allowed' });
+  }
+
+  const wsId = (req.query.workspace as string) || await getActiveWorkspaceId();
+  if (!wsId) {
+    return res.status(400).json({ error: 'No workspace found' });
+  }
+
+  const paneId = req.query.paneId as string;
+  const { tabIds } = req.body ?? {};
+
+  if (!Array.isArray(tabIds) || tabIds.length === 0) {
+    return res.status(400).json({ error: 'tabIds array required' });
+  }
+
+  const result = await reorderTabsInPane(wsId, paneId, tabIds);
+  if (!result) {
+    return res.status(404).json({ error: 'Target not found' });
+  }
+  return res.status(200).json(result);
+};
+
+export default handler;