@excitedjs/tm 1.1.0

package/bin/tm

@@ -0,0 +1,76 @@
+#!/usr/bin/env bash
+# tm — the dispatcher's CLI: tmux teammate manager, plus task-ledger and
+# context-usage helpers for dispatcher bookkeeping.
+#
+# This launcher runs the TypeScript sources under `../src/` directly through
+# Node 22's experimental type-transform pipeline. There is no build step and
+# no `npm install`: the only runtime npm dependency, `ws`, is vendored under
+# `../third_party/ws/` and consumed via the `#ws` subpath in
+# `../package.json`'s `imports` map. A small ESM resolve hook
+# (`../resolver-register.mjs`) lets the type-stripper accept the tree's
+# extension-less and `.js` import specifiers (the codex-protocol bindings
+# are generator output we do not rewrite).
+#
+# Requirements: Node 22.7 or newer (`--experimental-transform-types` ships
+# in 22.7, and the vendored `ws` consumes its CJS lib files via the upstream
+# ESM `wrapper.mjs`, which has been supported well before that). The
+# `--no-warnings` flag suppresses the per-launch `ExperimentalWarning` Node
+# emits for the type-transform flag.
+
+set -eu
+
+# Follow the script's own symlink chain. BSD `readlink` (macOS) has no `-f`,
+# so we loop manually — necessary when a user symlinks this launcher into
+# their PATH (`ln -s .../plugins/claudemux/bin/tm ~/.local/bin/tm`): a plain
+# `dirname "$0"` resolves to the symlink's directory, not the real script's,
+# and the relative `../core/...` lookups miss.
+SCRIPT="$0"
+while [[ -L "$SCRIPT" ]]; do
+    LINK_DIR="$(cd "$(dirname "$SCRIPT")" && pwd -P)"
+    LINK_TARGET="$(readlink "$SCRIPT")"
+    if [[ "$LINK_TARGET" = /* ]]; then
+        SCRIPT="$LINK_TARGET"
+    else
+        SCRIPT="$LINK_DIR/$LINK_TARGET"
+    fi
+done
+HERE="$(cd "$(dirname "$SCRIPT")" && pwd -P)"
+ROOT="$HERE/.."
+ENTRY="$ROOT/src/main.ts"
+REGISTER="$ROOT/resolver-register.mjs"
+
+if ! command -v node >/dev/null 2>&1; then
+    echo "tm: node not found on PATH. Install Node 22.7+ (https://nodejs.org/) and try again." >&2
+    exit 1
+fi
+
+# Reject older Node versions with an actionable message — otherwise the user
+# hits an opaque "invalid option: --experimental-transform-types" from a
+# Node that does not know the flag. The vendored `#ws` path goes through
+# the upstream `wrapper.mjs`, which ESM-imports the CJS lib files; that
+# direction has been supported since well before 22.7, so this guard's
+# only constraint is the transform-types flag itself (22.7+).
+NODE_VERSION="$(node -p 'process.versions.node' 2>/dev/null || echo 0.0.0)"
+NODE_MAJOR="${NODE_VERSION%%.*}"
+NODE_REST="${NODE_VERSION#*.}"
+NODE_MINOR="${NODE_REST%%.*}"
+if [[ "$NODE_MAJOR" -lt 22 ]] || { [[ "$NODE_MAJOR" -eq 22 ]] && [[ "$NODE_MINOR" -lt 7 ]]; }; then
+    echo "tm: requires Node 22.7 or newer (found v$NODE_VERSION). Upgrade Node and try again." >&2
+    exit 1
+fi
+
+if [[ ! -f "$ENTRY" ]]; then
+    echo "tm: orchestration entry missing at $ENTRY — expected the plugin's src/ tree alongside this launcher." >&2
+    exit 1
+fi
+
+if [[ ! -f "$REGISTER" ]]; then
+    echo "tm: resolver hook missing at $REGISTER — expected at the plugin root." >&2
+    exit 1
+fi
+
+exec node \
+    --import "$REGISTER" \
+    --experimental-transform-types \
+    --no-warnings \
+    "$ENTRY" "$@"

package/package.json

@@ -0,0 +1,39 @@
+{
+  "name": "@excitedjs/tm",
+  "version": "1.1.0",
+  "description": "Multi-repo AI orchestrator CLI — spawn, message, and wait on Claude/Codex teammates across sibling repos.",
+  "type": "module",
+  "license": "MIT",
+  "engines": {
+    "node": ">=22.7.0"
+  },
+  "imports": {
+    "#ws": "./third_party/ws/wrapper.mjs"
+  },
+  "bin": {
+    "tm": "./bin/tm"
+  },
+  "files": [
+    "bin/tm",
+    "src/",
+    "resolver.mjs",
+    "resolver-register.mjs",
+    "third_party/ws/"
+  ],
+  "scripts": {
+    "changeset": "changeset",
+    "version-packages": "changeset version && node scripts/sync-plugin-version.mjs",
+    "version-ga": "changeset pre exit && changeset version && node scripts/sync-plugin-version.mjs",
+    "test": "vitest run",
+    "typecheck": "tsc --noEmit",
+    "lint:dead-code": "node scripts/check-dead-code.mjs"
+  },
+  "devDependencies": {
+    "@changesets/cli": "2.31.0",
+    "@types/node": "^22.0.0",
+    "@types/ws": "^8.18.1",
+    "knip": "5.80.2",
+    "typescript": "^5.6.0",
+    "vitest": "^3.0.0"
+  }
+}

package/resolver-register.mjs

@@ -0,0 +1,7 @@
+// Registers the resolve hook in `./resolver.mjs` on the active loader chain.
+// `--import` only runs this file — it does not auto-register its hooks —
+// so we call `module.register` ourselves. See `resolver.mjs` for the
+// rules the hook applies and why they are needed at all.
+import { register } from 'node:module'
+
+register('./resolver.mjs', import.meta.url)

package/resolver.mjs

@@ -0,0 +1,86 @@
+// ESM resolve hook used by the `tm` launcher to let Node's
+// `--experimental-strip-types` run the TypeScript sources as-is, without
+// pre-rewriting every import.
+//
+// Node's native type stripping insists on explicit `.ts` extensions in
+// import specifiers; the codex-protocol bindings under `src/codex-protocol/`
+// are emitted by `codex app-server generate-ts` with extension-less imports
+// (the rest of the source mostly uses NodeNext-style `.js` specifiers that
+// also need rewriting). Sweeping the tree would be a permanent maintenance
+// tax — every codex CLI bump regenerates extension-less imports and the
+// "codex-protocol not stale" CI gate would push them back in.
+//
+// This hook fills the gap. Three rules, applied only to relative specifiers
+// whose default resolution fails:
+//   1. `./foo`    -> try `./foo.ts`, then `./foo/index.ts`
+//   2. `./foo.js` -> try the sibling `./foo.ts`
+//   3. everything else -> defer to the next resolver
+//
+// Bare-name imports such as `ws` are handled by the `imports` map in
+// `package.json` (`#ws`), not by this hook — vitest does not run this hook,
+// and the import map is the one mechanism both Node and vitest honor.
+
+import { existsSync } from 'node:fs'
+import { fileURLToPath } from 'node:url'
+
+const TS_EXTS = ['.ts', '.mts', '.cts']
+
+function tryResolveAsFile(urlString) {
+  try {
+    const path = fileURLToPath(urlString)
+    if (existsSync(path)) return urlString
+  } catch {
+    // not a file: URL — leave it to the default resolver
+  }
+  return null
+}
+
+function tryWithTsExtension(specifier, parentURL) {
+  if (!specifier.startsWith('./') && !specifier.startsWith('../')) return null
+  if (!parentURL) return null
+
+  const base = new URL(specifier, parentURL)
+  const baseHref = base.href
+
+  // .js -> sibling .ts (NodeNext convention used by hand-written sources)
+  if (baseHref.endsWith('.js')) {
+    const tsHref = baseHref.slice(0, -'.js'.length) + '.ts'
+    const hit = tryResolveAsFile(tsHref)
+    if (hit) return hit
+  }
+
+  // extension-less -> try each TS extension, then /index.ts
+  // (codex-protocol generator emits extension-less imports)
+  const hasExt = /\.[A-Za-z0-9]+$/.test(baseHref)
+  if (!hasExt) {
+    for (const ext of TS_EXTS) {
+      const hit = tryResolveAsFile(baseHref + ext)
+      if (hit) return hit
+    }
+    for (const ext of TS_EXTS) {
+      const hit = tryResolveAsFile(baseHref + '/index' + ext)
+      if (hit) return hit
+    }
+  }
+
+  return null
+}
+
+export async function resolve(specifier, context, nextResolve) {
+  try {
+    return await nextResolve(specifier, context)
+  } catch (err) {
+    if (err && err.code !== 'ERR_MODULE_NOT_FOUND' && err.code !== 'ERR_UNSUPPORTED_DIR_IMPORT') {
+      throw err
+    }
+    const rewritten = tryWithTsExtension(specifier, context.parentURL)
+    if (rewritten) {
+      // Hand the rewritten URL back through the resolver chain so Node's
+      // TypeScript pipeline picks the format from the `.ts` extension —
+      // hard-coding a format breaks across the strip-types / transform-types
+      // toggle.
+      return await nextResolve(rewritten, context)
+    }
+    throw err
+  }
+}

package/src/cli/context.ts

@@ -0,0 +1,63 @@
+import { homedir } from 'node:os'
+import { join } from 'node:path'
+
+import { runColumn } from '../column'
+import { createClaudeIdentityMigrator } from '../engines/claude/identity-migration'
+import { createCodexIdentityMigrator } from '../engines/codex/identity-migration'
+import { productionRegistry } from '../engines/production'
+import type { EngineContext } from '../engines/types'
+import type { NativeEnv } from '../env'
+import { runGrep } from '../grep'
+import { ProductionTeammateRouter } from '../identity/router'
+import { ProductionIdentityStore } from '../persistence/identity-writer'
+import { runTmux } from '../tmux'
+import type { VerbContext } from '../verbs/context'
+
+/**
+ * The verb-side context the engine-routed verbs consume. The router reads
+ * the identity JSON; the migrators only materialise that JSON for live
+ * teammates spawned before the identity store existed.
+ */
+export function productionVerbContext(env: NativeEnv): VerbContext {
+  const registry = env.engines ?? productionRegistry(env)
+
+  const migrateCodexIdentity = createCodexIdentityMigrator(env)
+  const migrateClaudeIdentity = createClaudeIdentityMigrator(env)
+  const router = new ProductionTeammateRouter(registry, async (name) => {
+    await migrateCodexIdentity(name)
+    await migrateClaudeIdentity(name)
+  })
+
+  const engineContext: EngineContext = { now: () => Date.now(), env: process.env }
+  return {
+    engines: registry,
+    router,
+    engineContext,
+    identity: new ProductionIdentityStore(),
+    runColumn: env.runColumn,
+  }
+}
+
+/** The production `NativeEnv` — the real backends, resolved once per invocation. */
+export function productionEnv(): NativeEnv {
+  const env: NativeEnv = {
+    runTmux,
+    runColumn,
+    runGrep,
+    // `tm` resolves the dispatcher dir from `TM_DISPATCHER_DIR` or
+    // `$PWD` (bash's `${TM_DISPATCHER_DIR:-$PWD}`). Two semantics matter:
+    //   - `$PWD` is the *logical* cwd, preserving the symlink the user
+    //     `cd`'d through; Node's `process.cwd()` would return the
+    //     symlink-resolved physical path, and `~/.claude/projects`
+    //     lookups would diverge between bash and native on a symlinked
+    //     dispatcher tree.
+    //   - bash `${VAR:-default}` triggers the default on *unset* OR
+    //     *empty*, so `||` (which treats empty strings as falsy) is the
+    //     right operator — `??` would let an accidentally-empty
+    //     `TM_DISPATCHER_DIR` through and resolve `<repo>` paths against
+    //     `""`.
+    dispatcherDir: process.env.TM_DISPATCHER_DIR || process.env.PWD || process.cwd(),
+    projectsDir: join(process.env.HOME ?? homedir(), '.claude', 'projects'),
+  }
+  return { ...env, engines: productionRegistry(env) }
+}