tmux-team 4.0.0 → 4.2.0

package/src/context.ts

@@ -18,9 +18,15 @@ export function createContext(options: CreateContextOptions): Context {
   const { argv, flags, cwd = process.cwd() } = options;
 
   const paths = resolvePaths(cwd, flags.team);
-  const config = loadConfig(paths);
   const ui = createUI(flags.json);
   const tmux = createTmux();
+  const registryScope = flags.team
+    ? { type: 'team' as const, teamName: flags.team }
+    : {
+        type: 'workspace' as const,
+        workspaceRoot: paths.workspaceRoot ?? cwd,
+      };
+  const config = loadConfig(paths, tmux.getAgentRegistry(registryScope));
 
   return {
     argv,
@@ -29,6 +35,7 @@ export function createContext(options: CreateContextOptions): Context {
     config,
     tmux,
     paths,
+    registryScope,
     exit(code: number): never {
       process.exit(code);
     },

package/src/identity.test.ts

@@ -1,18 +1,15 @@
 import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
 import type { PaneEntry } from './types.js';
 import { resolveActor } from './identity.js';
-import { execSync } from 'child_process';
 
 vi.mock('child_process', () => ({
   execSync: vi.fn(),
 }));
 
-const mockedExec = vi.mocked(execSync);
-
 describe('resolveActor', () => {
   const paneRegistry: Record<string, PaneEntry> = {
-    claude: { pane: '10.0' },
-    codex: { pane: '10.1' },
+    claude: { pane: '%98' },
+    codex: { pane: '%99' },
   };
 
   beforeEach(() => {
@@ -41,7 +38,6 @@ describe('resolveActor', () => {
   it('uses pane identity when in tmux and pane matches registry', () => {
     process.env.TMUX = '1';
     process.env.TMUX_PANE = '%99';
-    mockedExec.mockReturnValue('10.1\n');
     const res = resolveActor(paneRegistry);
     expect(res.actor).toBe('codex');
     expect(res.source).toBe('pane');
@@ -51,7 +47,6 @@ describe('resolveActor', () => {
     process.env.TMUX = '1';
     process.env.TMUX_PANE = '%99';
     process.env.TMT_AGENT_NAME = 'claude';
-    mockedExec.mockReturnValue('10.1\n');
     const res = resolveActor(paneRegistry);
     expect(res.actor).toBe('codex');
     expect(res.warning).toContain('Identity mismatch');
@@ -59,9 +54,8 @@ describe('resolveActor', () => {
 
   it('uses env actor with warning when pane is unregistered', () => {
     process.env.TMUX = '1';
-    process.env.TMUX_PANE = '%99';
+    process.env.TMUX_PANE = '%100';
     process.env.TMT_AGENT_NAME = 'someone';
-    mockedExec.mockReturnValue('99.9\n');
     const res = resolveActor(paneRegistry);
     expect(res.actor).toBe('someone');
     expect(res.source).toBe('env');

package/src/identity.ts

@@ -12,7 +12,7 @@ export interface ActorResolution {
 }
 
 /**
- * Get current tmux pane ID (e.g., "1.0").
+ * Get current tmux pane ID (e.g., "%12").
  */
 function getCurrentPane(): string | null {
   if (!process.env.TMUX) {
@@ -20,16 +20,14 @@ function getCurrentPane(): string | null {
   }
 
   const tmuxPane = process.env.TMUX_PANE;
-  if (!tmuxPane) {
-    return null;
-  }
+  if (tmuxPane) return tmuxPane;
 
   try {
-    const result = execSync(
-      `tmux display-message -p -t "${tmuxPane}" '#{window_index}.#{pane_index}'`,
-      { encoding: 'utf-8', stdio: ['pipe', 'pipe', 'pipe'] }
-    );
-    return result.trim();
+    const result = execSync(`tmux display-message -p '#{pane_id}'`, {
+      encoding: 'utf-8',
+      stdio: ['pipe', 'pipe', 'pipe'],
+    });
+    return result.trim() || null;
   } catch {
     return null;
   }

package/src/registry.test.ts

@@ -0,0 +1,61 @@
+import { describe, expect, it } from 'vitest';
+import type { Context } from './types.js';
+import { getRegistryScope, registrationFromEntry, scopeLabel } from './registry.js';
+
+function ctx(overrides: Partial<Context>): Context {
+  return {
+    argv: [],
+    flags: { json: false, verbose: false },
+    ui: {} as Context['ui'],
+    config: {} as Context['config'],
+    tmux: {} as Context['tmux'],
+    paths: {
+      globalDir: '/g',
+      globalConfig: '/g/c',
+      localConfig: '/r/tmux-team.json',
+      stateFile: '/g/s',
+      workspaceRoot: '/repo',
+    },
+    exit: (() => {
+      throw new Error('exit');
+    }) as Context['exit'],
+    ...overrides,
+  };
+}
+
+describe('registry helpers', () => {
+  it('prefers explicit context registry scope', () => {
+    const scope = { type: 'team' as const, teamName: 'egp' };
+    expect(getRegistryScope(ctx({ registryScope: scope }))).toBe(scope);
+  });
+
+  it('uses --team when no explicit scope exists', () => {
+    expect(getRegistryScope(ctx({ flags: { json: false, verbose: false, team: 'egp' } }))).toEqual({
+      type: 'team',
+      teamName: 'egp',
+    });
+  });
+
+  it('falls back to workspace scope', () => {
+    expect(getRegistryScope(ctx({}))).toEqual({ type: 'workspace', workspaceRoot: '/repo' });
+    expect(scopeLabel({ type: 'workspace', workspaceRoot: '/repo' })).toBe('workspace /repo');
+    expect(scopeLabel({ type: 'team', teamName: 'egp' })).toBe('team "egp"');
+  });
+
+  it('converts pane entries into registrations', () => {
+    expect(
+      registrationFromEntry('codex', {
+        pane: '%1',
+        remark: 'review',
+        preamble: 'Be strict',
+        deny: ['x'],
+      })
+    ).toEqual({
+      name: 'codex',
+      remark: 'review',
+      preamble: 'Be strict',
+      deny: ['x'],
+    });
+    expect(registrationFromEntry('codex')).toEqual({ name: 'codex' });
+  });
+});

package/src/registry.ts

@@ -0,0 +1,29 @@
+// ─────────────────────────────────────────────────────────────
+// Registry helpers for workspace/team scoped agent metadata
+// ─────────────────────────────────────────────────────────────
+
+import type { AgentRegistration, Context, PaneEntry, RegistryScope } from './types.js';
+
+export function getRegistryScope(ctx: Context): RegistryScope {
+  if (ctx.registryScope) return ctx.registryScope;
+  if (ctx.flags.team) {
+    return { type: 'team', teamName: ctx.flags.team };
+  }
+  return {
+    type: 'workspace',
+    workspaceRoot: ctx.paths.workspaceRoot ?? process.cwd(),
+  };
+}
+
+export function scopeLabel(scope: RegistryScope): string {
+  return scope.type === 'team' ? `team "${scope.teamName}"` : `workspace ${scope.workspaceRoot}`;
+}
+
+export function registrationFromEntry(name: string, entry?: PaneEntry): AgentRegistration {
+  return {
+    name,
+    ...(entry?.remark !== undefined && { remark: entry.remark }),
+    ...(entry?.preamble !== undefined && { preamble: entry.preamble }),
+    ...(entry?.deny !== undefined && { deny: entry.deny }),
+  };
+}

package/src/tmux.test.ts

@@ -3,15 +3,17 @@
 // ─────────────────────────────────────────────────────────────
 
 import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
-import { execSync } from 'child_process';
+import { execFileSync, execSync } from 'child_process';
 import { createTmux } from './tmux.js';
 
 // Mock child_process
 vi.mock('child_process', () => ({
   execSync: vi.fn(),
+  execFileSync: vi.fn(),
 }));
 
 const mockedExecSync = vi.mocked(execSync);
+const mockedExecFileSync = vi.mocked(execFileSync);
 
 describe('createTmux', () => {
   beforeEach(() => {
@@ -192,6 +194,56 @@ describe('createTmux', () => {
         { id: '%2', command: 'codex', suggestedName: 'codex' },
       ]);
     });
+
+    it('ignores invalid metadata and duplicate pane IDs', () => {
+      mockedExecSync.mockReturnValue('%1\tcodex\tbad-json\n%1\tcodex\tbad-json\n%2\tzsh\t{}\n');
+      const tmux = createTmux();
+      expect(tmux.listPanes()).toEqual([
+        { id: '%1', command: 'codex', suggestedName: 'codex' },
+        { id: '%2', command: 'zsh', suggestedName: null },
+      ]);
+      expect(tmux.getAgentRegistry({ type: 'workspace', workspaceRoot: '/repo' })).toEqual({
+        paneRegistry: {},
+        agents: {},
+      });
+    });
+
+    it('parses tmux-team pane metadata', () => {
+      mockedExecSync.mockReturnValue(
+        '%1\tcodex\t{"version":1,"workspaces":{"/repo":{"name":"codex","remark":"review"}}}\n'
+      );
+      const tmux = createTmux();
+      expect(tmux.getAgentRegistry({ type: 'workspace', workspaceRoot: '/repo' })).toEqual({
+        paneRegistry: { codex: { pane: '%1', remark: 'review' } },
+        agents: {},
+      });
+    });
+
+    it('parses pane target and cwd from modern list-panes output', () => {
+      mockedExecSync.mockReturnValue('%1\tmain:2.0\t/repo\tcodex\t{"version":1}\n');
+      const tmux = createTmux();
+      expect(tmux.listPanes()).toEqual([
+        {
+          id: '%1',
+          target: 'main:2.0',
+          cwd: '/repo',
+          command: 'codex',
+          suggestedName: 'codex',
+          metadata: { version: 1 },
+        },
+      ]);
+    });
+
+    it('builds team registries and agent config from metadata', () => {
+      mockedExecSync.mockReturnValue(
+        '%1\tcodex\t{"version":1,"teams":{"egp":{"name":"codex","preamble":"Be strict","deny":["x"]}}}\n'
+      );
+      const tmux = createTmux();
+      expect(tmux.getAgentRegistry({ type: 'team', teamName: 'egp' })).toEqual({
+        paneRegistry: { codex: { pane: '%1', preamble: 'Be strict', deny: ['x'] } },
+        agents: { codex: { preamble: 'Be strict', deny: ['x'] } },
+      });
+    });
   });
 
   describe('getCurrentPaneId', () => {
@@ -233,6 +285,143 @@ describe('createTmux', () => {
     });
   });
 
+  describe('metadata registry writes', () => {
+    it('resolves pane targets to canonical pane IDs', () => {
+      mockedExecFileSync.mockReturnValue('%9\n');
+      const tmux = createTmux();
+      expect(tmux.resolvePaneTarget('1.2')).toBe('%9');
+      expect(mockedExecFileSync).toHaveBeenCalledWith(
+        'tmux',
+        ['display-message', '-p', '-t', '1.2', '#{pane_id}'],
+        expect.any(Object)
+      );
+    });
+
+    it('sets workspace registration on pane metadata', () => {
+      mockedExecFileSync.mockReturnValueOnce('');
+      const tmux = createTmux();
+      tmux.setAgentRegistration(
+        '%9',
+        { type: 'workspace', workspaceRoot: '/repo' },
+        { name: 'codex', preamble: 'Be strict' }
+      );
+      expect(mockedExecFileSync).toHaveBeenLastCalledWith(
+        'tmux',
+        [
+          'set-option',
+          '-p',
+          '-t',
+          '%9',
+          '@tmux-team.agent',
+          '{"version":1,"workspaces":{"/repo":{"name":"codex","preamble":"Be strict"}}}',
+        ],
+        expect.any(Object)
+      );
+    });
+
+    it('sets team registration while preserving existing metadata', () => {
+      mockedExecFileSync.mockReturnValueOnce(
+        '{"version":1,"workspaces":{"/repo":{"name":"codex"}}}\n'
+      );
+      const tmux = createTmux();
+      tmux.setAgentRegistration('%9', { type: 'team', teamName: 'egp' }, { name: 'reviewer' });
+      expect(mockedExecFileSync).toHaveBeenLastCalledWith(
+        'tmux',
+        [
+          'set-option',
+          '-p',
+          '-t',
+          '%9',
+          '@tmux-team.agent',
+          '{"version":1,"workspaces":{"/repo":{"name":"codex"}},"teams":{"egp":{"name":"reviewer"}}}',
+        ],
+        expect.any(Object)
+      );
+    });
+
+    it('clears scoped registration and unsets empty metadata', () => {
+      mockedExecSync.mockReturnValue(
+        '%1\tcodex\t{"version":1,"workspaces":{"/repo":{"name":"codex"}}}\n'
+      );
+      const tmux = createTmux();
+      expect(
+        tmux.clearAgentRegistration('codex', { type: 'workspace', workspaceRoot: '/repo' })
+      ).toBe(true);
+      expect(mockedExecFileSync).toHaveBeenCalledWith(
+        'tmux',
+        ['set-option', '-p', '-u', '-t', '%1', '@tmux-team.agent'],
+        expect.any(Object)
+      );
+    });
+
+    it('returns false when clearing a missing registration', () => {
+      mockedExecSync.mockReturnValue(
+        '%1\tcodex\t{"version":1,"workspaces":{"/repo":{"name":"codex"}}}\n'
+      );
+      const tmux = createTmux();
+      expect(
+        tmux.clearAgentRegistration('claude', { type: 'workspace', workspaceRoot: '/repo' })
+      ).toBe(false);
+      expect(mockedExecFileSync).not.toHaveBeenCalled();
+    });
+
+    it('lists teams from pane metadata', () => {
+      mockedExecSync.mockReturnValue(
+        '%1\tcodex\t{"version":1,"teams":{"egp":{"name":"codex"},"checkout":{"name":"claude"}}}\n'
+      );
+      const tmux = createTmux();
+      expect(tmux.listTeams()).toEqual({ checkout: ['claude'], egp: ['codex'] });
+    });
+
+    it('lists pane team and workspace details', () => {
+      mockedExecSync.mockReturnValue(
+        '%1\tmain:1.0\t/repo\tclaude\t{"version":1,"workspaces":{"/repo":{"name":"claude","remark":"lead"}},"teams":{"egp":{"name":"reviewer"}}}\n%2\tmain:1.1\t/tmp\tzsh\t\n'
+      );
+      const tmux = createTmux();
+      expect(tmux.listTeamPanes()).toEqual([
+        {
+          pane: '%1',
+          target: 'main:1.0',
+          cwd: '/repo',
+          command: 'claude',
+          suggestedName: 'claude',
+          registrations: [
+            { scopeType: 'team', scope: 'egp', agent: 'reviewer' },
+            { scopeType: 'workspace', scope: '/repo', agent: 'claude', remark: 'lead' },
+          ],
+        },
+        {
+          pane: '%2',
+          target: 'main:1.1',
+          cwd: '/tmp',
+          command: 'zsh',
+          suggestedName: null,
+          registrations: [],
+        },
+      ]);
+    });
+
+    it('removes one team while preserving other registrations', () => {
+      mockedExecSync.mockReturnValue(
+        '%1\tcodex\t{"version":1,"teams":{"egp":{"name":"codex"},"checkout":{"name":"claude"}}}\n'
+      );
+      const tmux = createTmux();
+      expect(tmux.removeTeam('egp')).toEqual({ removed: 1, agents: ['codex'] });
+      expect(mockedExecFileSync).toHaveBeenCalledWith(
+        'tmux',
+        [
+          'set-option',
+          '-p',
+          '-t',
+          '%1',
+          '@tmux-team.agent',
+          '{"version":1,"teams":{"checkout":{"name":"claude"}}}',
+        ],
+        expect.any(Object)
+      );
+    });
+  });
+
   describe('pane ID handling', () => {
     it('accepts window.pane format', () => {
       mockedExecSync.mockReturnValue('');