create-semaphor-app 0.1.0

package/README.md

@@ -0,0 +1,59 @@
+# create-semaphor-app
+
+Create a Semaphor Data App starter project.
+
+```bash
+npx create-semaphor-app@latest customer-health
+```
+
+The CLI scaffolds the public Semaphor Data App Starter, installs local
+dependencies by default, and can optionally install the Semaphor Agent Plugin
+for detected Codex and Claude Code installations.
+
+It does not authenticate to Semaphor, write tokens, or choose a project/domain.
+The Semaphor Agent Plugin handles OAuth, project selection, runtime token
+minting, planning, code generation, validation, save, and publish.
+
+## Usage
+
+```bash
+npx create-semaphor-app@latest <app-name>
+```
+
+Options:
+
+```text
+--no-install              Skip dependency installation.
+--package-manager <name>  Use npm, pnpm, yarn, or bun. Defaults to detected npm.
+--skip-plugin             Skip Codex/Claude plugin install prompts.
+--install-codex-plugin    Install the Codex plugin without prompting.
+--install-claude-plugin   Install the Claude Code plugin without prompting.
+--template <source>       Starter source. Defaults to the public starter repo.
+--template-ref <ref>      Git branch/tag for the default starter repo. Defaults to main.
+--yes                     Use noninteractive defaults; skip optional plugin installs unless explicit.
+--help                    Show help.
+```
+
+## Local Validation
+
+```bash
+npm test
+```
+
+The smoke test creates temporary projects under the OS temp directory, verifies
+the local and default starter scaffold paths, exercises fake Codex plugin
+installation without touching the real Codex install, and removes the temporary
+projects before exiting.
+
+After creation:
+
+```bash
+cd customer-health
+npm run dev
+```
+
+Then open Codex or Claude Code in the project and ask:
+
+```text
+@semaphor Build a Data App from my Semaphor project.
+```

package/bin/create-semaphor-app.mjs

@@ -0,0 +1,532 @@
+#!/usr/bin/env node
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import process from 'node:process';
+import readline from 'node:readline/promises';
+import { spawnSync } from 'node:child_process';
+import { fileURLToPath } from 'node:url';
+
+const DEFAULT_TEMPLATE_REPO =
+  'https://github.com/semaphor-analytics/semaphor-data-app-starter.git';
+const DEFAULT_TEMPLATE_REF = 'main';
+const MARKETPLACE = 'semaphor-analytics/agent-plugin';
+const PLUGIN_ID = 'semaphor@semaphor-analytics';
+const canPrompt = Boolean(process.stdin.isTTY && process.stdout.isTTY);
+
+const cwd = process.cwd();
+
+function usage() {
+  return `Create a Semaphor Data App starter project.
+
+Usage:
+  npx create-semaphor-app@latest <app-name> [options]
+
+Options:
+  --no-install              Skip dependency installation.
+  --package-manager <name>  Use npm, pnpm, yarn, or bun.
+  --skip-plugin             Skip Codex/Claude plugin install prompts.
+  --install-codex-plugin    Install the Codex plugin without prompting.
+  --install-claude-plugin   Install the Claude Code plugin without prompting.
+  --template <source>       Starter source. Can be a local directory or git URL.
+  --template-ref <ref>      Git branch/tag for the default starter repo.
+  --yes, -y                 Use noninteractive defaults; skip optional plugin installs unless explicit.
+  --help, -h                Show this help.
+`;
+}
+
+function parseArgs(argv) {
+  const parsed = {
+    appName: null,
+    install: true,
+    packageManager: null,
+    skipPlugin: false,
+    installCodexPlugin: false,
+    installClaudePlugin: false,
+    template: DEFAULT_TEMPLATE_REPO,
+    templateRef: DEFAULT_TEMPLATE_REF,
+    yes: false,
+    help: false,
+  };
+
+  for (let i = 2; i < argv.length; i += 1) {
+    const arg = argv[i];
+    if (arg === '--help' || arg === '-h') {
+      parsed.help = true;
+    } else if (arg === '--no-install') {
+      parsed.install = false;
+    } else if (arg === '--package-manager') {
+      parsed.packageManager = readRequiredValue(argv, ++i, arg);
+    } else if (arg.startsWith('--package-manager=')) {
+      parsed.packageManager = arg.slice('--package-manager='.length);
+    } else if (arg === '--skip-plugin') {
+      parsed.skipPlugin = true;
+    } else if (arg === '--install-codex-plugin') {
+      parsed.installCodexPlugin = true;
+    } else if (arg === '--install-claude-plugin') {
+      parsed.installClaudePlugin = true;
+    } else if (arg === '--template') {
+      parsed.template = readRequiredValue(argv, ++i, arg);
+    } else if (arg.startsWith('--template=')) {
+      parsed.template = arg.slice('--template='.length);
+    } else if (arg === '--template-ref') {
+      parsed.templateRef = readRequiredValue(argv, ++i, arg);
+    } else if (arg.startsWith('--template-ref=')) {
+      parsed.templateRef = arg.slice('--template-ref='.length);
+    } else if (arg === '--yes' || arg === '-y') {
+      parsed.yes = true;
+    } else if (arg.startsWith('-')) {
+      throw new Error(`Unknown option: ${arg}`);
+    } else if (!parsed.appName) {
+      parsed.appName = arg;
+    } else {
+      throw new Error(`Unexpected argument: ${arg}`);
+    }
+  }
+
+  return parsed;
+}
+
+function readRequiredValue(argv, index, optionName) {
+  const value = argv[index];
+  if (!value || value.startsWith('-')) {
+    throw new Error(`${optionName} requires a value.`);
+  }
+  return value;
+}
+
+function slugifyPackageName(name) {
+  const base = path.basename(name).trim().toLowerCase();
+  return (
+    base
+      .replace(/[^a-z0-9._~-]+/g, '-')
+      .replace(/^-+|-+$/g, '')
+      .slice(0, 214) || 'semaphor-data-app'
+  );
+}
+
+function isSafeRelativeTarget(name) {
+  return Boolean(name) && !path.isAbsolute(name) && !name.split(/[\\/]/).includes('..');
+}
+
+function ensureCommand(command, label) {
+  const result = spawnSync(command, ['--version'], {
+    stdio: 'ignore',
+    shell: false,
+  });
+  if (result.error || result.status !== 0) {
+    throw new Error(`${label} is required but was not found in PATH.`);
+  }
+}
+
+function commandExists(command) {
+  const result = spawnSync(command, ['--version'], {
+    stdio: 'ignore',
+    shell: false,
+  });
+  return !result.error && result.status === 0;
+}
+
+function run(command, args, options = {}) {
+  const result = spawnSync(command, args, {
+    cwd: options.cwd || cwd,
+    stdio: options.stdio || 'inherit',
+    shell: false,
+    env: process.env,
+  });
+  return result;
+}
+
+function runRequired(command, args, options = {}) {
+  const result = run(command, args, options);
+  if (result.error) {
+    throw result.error;
+  }
+  if (result.status !== 0) {
+    throw new Error(`${command} ${args.join(' ')} failed.`);
+  }
+}
+
+function directoryEntries(dir) {
+  if (!fs.existsSync(dir)) return [];
+  return fs.readdirSync(dir).filter((entry) => entry !== '.DS_Store');
+}
+
+function shouldSkipTemplatePath(relativePath) {
+  const parts = relativePath.split(path.sep);
+  return parts.some((part) =>
+    ['.git', 'node_modules', 'dist', 'dist-ssr'].includes(part)
+  );
+}
+
+function copyDirectory(sourceDir, targetDir, options = {}) {
+  const copied = [];
+  const skipped = [];
+
+  function copyOne(currentSource, currentTarget, relativePath) {
+    if (relativePath && shouldSkipTemplatePath(relativePath)) {
+      skipped.push(relativePath);
+      return;
+    }
+
+    const stat = fs.statSync(currentSource);
+    if (stat.isDirectory()) {
+      fs.mkdirSync(currentTarget, { recursive: true });
+      for (const entry of fs.readdirSync(currentSource)) {
+        copyOne(
+          path.join(currentSource, entry),
+          path.join(currentTarget, entry),
+          relativePath ? path.join(relativePath, entry) : entry,
+        );
+      }
+      return;
+    }
+
+    if (fs.existsSync(currentTarget) && options.noOverwrite) {
+      skipped.push(relativePath);
+      return;
+    }
+
+    fs.mkdirSync(path.dirname(currentTarget), { recursive: true });
+    fs.copyFileSync(currentSource, currentTarget);
+    copied.push(relativePath);
+  }
+
+  copyOne(sourceDir, targetDir, '');
+  return { copied, skipped };
+}
+
+function updatePackageName(targetDir, packageName) {
+  const packageJsonPath = path.join(targetDir, 'package.json');
+  if (!fs.existsSync(packageJsonPath)) return;
+  const packageJson = JSON.parse(fs.readFileSync(packageJsonPath, 'utf8'));
+  packageJson.name = packageName;
+  fs.writeFileSync(
+    packageJsonPath,
+    `${JSON.stringify(packageJson, null, 2)}\n`,
+  );
+}
+
+function resolvePackageManager(requested) {
+  if (requested) {
+    const normalized = requested.toLowerCase();
+    if (!['npm', 'pnpm', 'yarn', 'bun'].includes(normalized)) {
+      throw new Error(
+        `Unsupported package manager "${requested}". Use npm, pnpm, yarn, or bun.`,
+      );
+    }
+    return normalized;
+  }
+  const userAgent = process.env.npm_config_user_agent || '';
+  if (userAgent.startsWith('pnpm/')) return 'pnpm';
+  if (userAgent.startsWith('yarn/')) return 'yarn';
+  if (userAgent.startsWith('bun/')) return 'bun';
+  return 'npm';
+}
+
+function installArgs(packageManager) {
+  if (packageManager === 'yarn') return [];
+  return ['install'];
+}
+
+function promptQuestion(rl, question, defaultYes) {
+  if (!canPrompt) {
+    return Promise.resolve(false);
+  }
+  const suffix = defaultYes ? ' [Y/n] ' : ' [y/N] ';
+  return rl.question(`${question}${suffix}`).then((answer) => {
+    const normalized = answer.trim().toLowerCase();
+    if (!normalized) return defaultYes;
+    return normalized === 'y' || normalized === 'yes';
+  });
+}
+
+async function resolveTarget(args, rl) {
+  if (!args.appName) {
+    if (!canPrompt) {
+      throw new Error('App name is required.');
+    }
+    args.appName = await rl.question('App name: ');
+  }
+
+  const trimmed = String(args.appName || '').trim();
+  if (!trimmed) {
+    throw new Error('App name is required.');
+  }
+  if (!isSafeRelativeTarget(trimmed)) {
+    throw new Error('Use a relative app directory name without "..".');
+  }
+
+  const targetDir = path.resolve(cwd, trimmed);
+  const entries = directoryEntries(targetDir);
+  let noOverwrite = false;
+
+  if (entries.length > 0) {
+    if (args.yes) {
+      throw new Error(
+        `Directory ${targetDir} already exists and is not empty. Choose another app name.`,
+      );
+    }
+    if (!canPrompt) {
+      throw new Error(
+        `Directory ${targetDir} already exists and is not empty. Choose another app name.`,
+      );
+    }
+    const proceed = await promptQuestion(
+      rl,
+      `Directory ${path.relative(cwd, targetDir)} is not empty. Merge starter files without overwriting existing files?`,
+      false,
+    );
+    if (!proceed) {
+      throw new Error('Canceled.');
+    }
+    noOverwrite = true;
+  }
+
+  fs.mkdirSync(targetDir, { recursive: true });
+  return { targetDir, packageName: slugifyPackageName(trimmed), noOverwrite };
+}
+
+function localTemplatePath(template) {
+  if (template.startsWith('file://')) {
+    return fileURLToPath(template);
+  }
+  const maybePath = path.resolve(cwd, template);
+  return fs.existsSync(maybePath) ? maybePath : null;
+}
+
+function loadTemplate(template, templateRef) {
+  const tempRoot = fs.mkdtempSync(path.join(os.tmpdir(), 'create-semaphor-app-'));
+  const localPath = localTemplatePath(template);
+
+  if (localPath) {
+    const templateDir = path.join(tempRoot, 'template');
+    copyDirectory(localPath, templateDir);
+    return { tempRoot, templateDir };
+  }
+
+  ensureCommand('git', 'git');
+  const templateDir = path.join(tempRoot, 'template');
+  const args = ['clone', '--depth', '1'];
+  if (template === DEFAULT_TEMPLATE_REPO && templateRef) {
+    args.push('--branch', templateRef);
+  }
+  args.push(template, templateDir);
+  runRequired('git', args, { stdio: 'inherit' });
+  fs.rmSync(path.join(templateDir, '.git'), { recursive: true, force: true });
+  return { tempRoot, templateDir };
+}
+
+function detectAgents() {
+  return {
+    codex: commandExists('codex'),
+    claude: commandExists('claude'),
+  };
+}
+
+function installCodexPlugin() {
+  console.log('\nInstalling Semaphor plugin for Codex...');
+  const marketplace = run('codex', [
+    'plugin',
+    'marketplace',
+    'add',
+    MARKETPLACE,
+  ]);
+  if (marketplace.error || marketplace.status !== 0) {
+    return {
+      ok: false,
+      error: 'Failed to add Semaphor Codex plugin marketplace.',
+    };
+  }
+
+  const plugin = run('codex', ['plugin', 'add', PLUGIN_ID]);
+  if (plugin.error || plugin.status !== 0) {
+    return { ok: false, error: 'Failed to install Semaphor Codex plugin.' };
+  }
+  return { ok: true };
+}
+
+function installClaudePlugin() {
+  console.log('\nInstalling Semaphor plugin for Claude Code...');
+  const marketplace = run('claude', [
+    'plugin',
+    'marketplace',
+    'add',
+    MARKETPLACE,
+  ]);
+  if (marketplace.error || marketplace.status !== 0) {
+    return {
+      ok: false,
+      error: 'Failed to add Semaphor Claude plugin marketplace.',
+    };
+  }
+
+  const plugin = run('claude', ['plugin', 'install', PLUGIN_ID]);
+  if (plugin.error || plugin.status !== 0) {
+    return { ok: false, error: 'Failed to install Semaphor Claude plugin.' };
+  }
+  return { ok: true };
+}
+
+async function maybeInstallPlugins(args, rl) {
+  const detected = detectAgents();
+  const results = [];
+
+  if (args.skipPlugin) {
+    return { detected, results, skipped: true };
+  }
+
+  console.log('\nAgent setup');
+  console.log(`Detected Codex: ${detected.codex ? 'yes' : 'no'}`);
+  console.log(`Detected Claude Code: ${detected.claude ? 'yes' : 'no'}`);
+
+  const shouldInstallCodex =
+    detected.codex &&
+    (args.installCodexPlugin ||
+      (!args.yes &&
+        canPrompt &&
+        (await promptQuestion(
+          rl,
+          'Install Semaphor plugin for Codex now?',
+          true,
+        ))));
+
+  if (shouldInstallCodex) {
+    results.push({ agent: 'Codex', ...installCodexPlugin() });
+  }
+
+  const shouldInstallClaude =
+    detected.claude &&
+    (args.installClaudePlugin ||
+      (!args.yes &&
+        canPrompt &&
+        (await promptQuestion(
+          rl,
+          'Install Semaphor plugin for Claude Code now?',
+          detected.codex ? false : true,
+        ))));
+
+  if (shouldInstallClaude) {
+    results.push({ agent: 'Claude Code', ...installClaudePlugin() });
+  }
+
+  return { detected, results, skipped: false };
+}
+
+function printNextSteps({ targetDir, packageManager, pluginSummary }) {
+  const relativeTarget = path.relative(cwd, targetDir) || '.';
+  console.log('\nNext:');
+  console.log(`  cd ${relativeTarget}`);
+  console.log(`  ${packageManager} run dev`);
+
+  console.log('\nThen open Codex or Claude Code in this folder and ask:');
+  console.log('  @semaphor Build a Data App from my Semaphor project.');
+
+  if (pluginSummary?.skipped) {
+    printPluginInstructions();
+    return;
+  }
+
+  const failures = pluginSummary?.results?.filter((result) => !result.ok) ?? [];
+  if (failures.length > 0) {
+    console.log('\nPlugin install had issues:');
+    for (const failure of failures) {
+      console.log(`  - ${failure.agent}: ${failure.error}`);
+    }
+    printPluginInstructions();
+    return;
+  }
+
+  const installed = pluginSummary?.results?.filter((result) => result.ok) ?? [];
+  if (installed.length > 0) {
+    console.log('\nInstalled Semaphor plugin for:');
+    for (const result of installed) {
+      console.log(`  - ${result.agent}`);
+    }
+    console.log('\nAuthenticate when your agent asks, or run:');
+    console.log('  codex mcp login semaphor');
+    return;
+  }
+
+  printPluginInstructions();
+}
+
+function printPluginInstructions() {
+  console.log('\nInstall the Semaphor plugin when you are ready:');
+  console.log('\nCodex:');
+  console.log(`  codex plugin marketplace add ${MARKETPLACE}`);
+  console.log(`  codex plugin add ${PLUGIN_ID}`);
+  console.log('  codex mcp login semaphor');
+  console.log('\nClaude Code:');
+  console.log(`  claude plugin marketplace add ${MARKETPLACE}`);
+  console.log(`  claude plugin install ${PLUGIN_ID}`);
+  console.log('  Use the Claude Code MCP auth flow for the semaphor server.');
+}
+
+async function main() {
+  let args;
+  try {
+    args = parseArgs(process.argv);
+  } catch (error) {
+    console.error(error instanceof Error ? error.message : String(error));
+    console.error('');
+    console.error(usage());
+    process.exit(1);
+  }
+
+  if (args.help) {
+    console.log(usage());
+    return;
+  }
+
+  const rl = readline.createInterface({
+    input: process.stdin,
+    output: process.stdout,
+  });
+
+  let tempRoot = null;
+  try {
+    console.log('\nSemaphor Data App\n');
+    const target = await resolveTarget(args, rl);
+    const packageManager = resolvePackageManager(args.packageManager);
+    console.log(`Creating app in ${target.targetDir}`);
+
+    const template = loadTemplate(args.template, args.templateRef);
+    tempRoot = template.tempRoot;
+    copyDirectory(template.templateDir, target.targetDir, {
+      noOverwrite: target.noOverwrite,
+    });
+    updatePackageName(target.targetDir, target.packageName);
+    console.log('✓ Created app');
+
+    if (args.install) {
+      ensureCommand(packageManager, packageManager);
+      console.log(`\nInstalling dependencies with ${packageManager}...`);
+      runRequired(packageManager, installArgs(packageManager), {
+        cwd: target.targetDir,
+        stdio: 'inherit',
+      });
+      console.log('✓ Installed dependencies');
+    } else {
+      console.log('Skipping dependency installation.');
+    }
+
+    const pluginSummary = await maybeInstallPlugins(args, rl);
+    printNextSteps({
+      targetDir: target.targetDir,
+      packageManager,
+      pluginSummary,
+    });
+  } catch (error) {
+    console.error('\nUnable to create Semaphor app.');
+    console.error(error instanceof Error ? error.message : String(error));
+    process.exitCode = 1;
+  } finally {
+    rl.close();
+    if (tempRoot) {
+      fs.rmSync(tempRoot, { recursive: true, force: true });
+    }
+  }
+}
+
+await main();

package/package.json

@@ -0,0 +1,29 @@
+{
+  "name": "create-semaphor-app",
+  "version": "0.1.0",
+  "description": "Create a Semaphor Data App starter project.",
+  "type": "module",
+  "bin": {
+    "create-semaphor-app": "bin/create-semaphor-app.mjs"
+  },
+  "files": [
+    "bin",
+    "scripts",
+    "README.md"
+  ],
+  "scripts": {
+    "check": "node --check bin/create-semaphor-app.mjs && node --check scripts/smoke-test.mjs",
+    "test": "node scripts/smoke-test.mjs"
+  },
+  "keywords": [
+    "semaphor",
+    "data-app",
+    "react",
+    "vite",
+    "starter"
+  ],
+  "license": "UNLICENSED",
+  "engines": {
+    "node": ">=20"
+  }
+}

package/scripts/smoke-test.mjs

@@ -0,0 +1,166 @@
+#!/usr/bin/env node
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import process from 'node:process';
+import { spawnSync } from 'node:child_process';
+import { fileURLToPath } from 'node:url';
+
+const repoRoot = path.resolve(
+  path.dirname(fileURLToPath(import.meta.url)),
+  '..',
+);
+const cliPath = path.join(repoRoot, 'bin', 'create-semaphor-app.mjs');
+const defaultLocalStarterPath =
+  process.env.SEMAPHOR_DATA_APP_STARTER_PATH ||
+  '/Users/rohit/code/semaphor/semaphor-data-app-starter';
+
+const tempRoots = [];
+
+function assert(condition, message) {
+  if (!condition) {
+    throw new Error(message);
+  }
+}
+
+function createTempRoot(label) {
+  const root = fs.mkdtempSync(path.join(os.tmpdir(), `create-semaphor-app-${label}-`));
+  tempRoots.push(root);
+  return root;
+}
+
+function run(command, args, options = {}) {
+  return spawnSync(command, args, {
+    cwd: options.cwd,
+    env: options.env || process.env,
+    encoding: 'utf8',
+    stdio: options.stdio || 'pipe',
+    shell: false,
+  });
+}
+
+function runCli(args, options = {}) {
+  return run(process.execPath, [cliPath, ...args], options);
+}
+
+function assertSuccess(result, label) {
+  if (result.error) {
+    throw result.error;
+  }
+  if (result.status !== 0) {
+    throw new Error(
+      `${label} failed with status ${result.status}\nstdout:\n${result.stdout}\nstderr:\n${result.stderr}`,
+    );
+  }
+}
+
+function readJson(filePath) {
+  return JSON.parse(fs.readFileSync(filePath, 'utf8'));
+}
+
+function assertScaffold(root, appName) {
+  const appRoot = path.join(root, appName);
+  const packageJson = readJson(path.join(appRoot, 'package.json'));
+
+  assert(packageJson.name === appName, `expected package name ${appName}`);
+  assert(
+    Boolean(packageJson.dependencies?.['react-semaphor']),
+    'expected react-semaphor dependency',
+  );
+  assert(fs.existsSync(path.join(appRoot, 'src', 'App.tsx')), 'expected src/App.tsx');
+  assert(!fs.existsSync(path.join(appRoot, '.git')), 'starter .git should not be copied');
+  assert(!fs.existsSync(path.join(appRoot, 'node_modules')), 'node_modules should not be copied');
+}
+
+function createFakeCommand(binDir, name, logFile) {
+  const filePath = path.join(binDir, name);
+  fs.writeFileSync(
+    filePath,
+    `#!/usr/bin/env sh
+echo "$0 $@" >> "${logFile}"
+if [ "$1" = "--version" ]; then echo "${name} test"; fi
+exit 0
+`,
+  );
+  fs.chmodSync(filePath, 0o755);
+}
+
+async function main() {
+  try {
+    console.log('create-semaphor-app smoke test');
+
+    assert(fs.existsSync(defaultLocalStarterPath), `starter not found: ${defaultLocalStarterPath}`);
+
+    {
+      const root = createTempRoot('local-');
+      const result = runCli([
+        'customer-health',
+        '--template',
+        defaultLocalStarterPath,
+        '--no-install',
+        '--skip-plugin',
+        '--yes',
+      ], { cwd: root });
+      assertSuccess(result, 'local starter scaffold');
+      assertScaffold(root, 'customer-health');
+      assert(result.stdout.includes('Skipping dependency installation.'), 'expected no-install output');
+      console.log('✓ local starter scaffold');
+    }
+
+    {
+      const root = createTempRoot('github-');
+      const result = runCli([
+        'github-template-app',
+        '--no-install',
+        '--skip-plugin',
+        '--yes',
+      ], { cwd: root });
+      assertSuccess(result, 'default GitHub starter scaffold');
+      assertScaffold(root, 'github-template-app');
+      console.log('✓ default GitHub starter scaffold');
+    }
+
+    {
+      const root = createTempRoot('fake-codex-');
+      const binDir = path.join(root, 'bin');
+      fs.mkdirSync(binDir, { recursive: true });
+      const codexLog = path.join(root, 'codex.log');
+      createFakeCommand(binDir, 'codex', codexLog);
+
+      const result = runCli([
+        'plugin-test-app',
+        '--template',
+        defaultLocalStarterPath,
+        '--no-install',
+        '--install-codex-plugin',
+      ], {
+        cwd: root,
+        env: {
+          ...process.env,
+          PATH: `${binDir}${path.delimiter}${process.env.PATH || ''}`,
+        },
+      });
+      assertSuccess(result, 'fake Codex plugin install');
+      assertScaffold(root, 'plugin-test-app');
+      const log = fs.readFileSync(codexLog, 'utf8');
+      assert(
+        log.includes('codex plugin marketplace add semaphor-analytics/agent-plugin'),
+        'expected codex marketplace add command',
+      );
+      assert(
+        log.includes('codex plugin add semaphor@semaphor-analytics'),
+        'expected codex plugin add command',
+      );
+      console.log('✓ fake Codex plugin install path');
+    }
+
+    console.log('✓ cleaned up temp projects');
+  } finally {
+    for (const root of tempRoots.reverse()) {
+      fs.rmSync(root, { recursive: true, force: true });
+    }
+  }
+}
+
+await main();
+