cc-orchestrator 0.2.7 → 0.2.9

package/README.md

@@ -1,33 +1,34 @@
 # cc-orchestrator
 
-One-line installer for [CC Orchestrator](https://github.com/zhsks311/cc-orchestratorestrator) - Multi-model orchestration for Claude Code.
+One-line installer for [CC Orchestrator](https://github.com/zhsks311/cc-orchestrator) - Multi-model orchestration for Claude Code.
 
 ## Quick Start
 
 ```bash
-npx cc-orchestrator
+npx cc-orchestrator@latest
 ```
 
 That's it! The installer will:
-1. Clone the repository to `~/.cc-orchestratorestrator`
-2. Install dependencies
-3. Run the interactive setup wizard
-4. Configure Claude Code automatically
+1. Clone the repository to `~/.cc-orchestrator`
+2. Check out the released git tag that matches the installer version
+3. Install dependencies
+4. Run the interactive setup wizard
+5. Configure Claude Code automatically
 
 ## Usage
 
 ```bash
-# Install to default location (~/.cc-orchestratorestrator)
-npx cc-orchestrator
+# Install to default location (~/.cc-orchestrator)
+npx cc-orchestrator@latest
 
 # Install to custom directory
-npx cc-orchestrator ./my-cco
+npx cc-orchestrator@latest ./my-cco
 
-# Update existing installation
-npx cc-orchestrator --upgrade
+# Update existing installation via the latest npm-published installer version
+npx cc-orchestrator@latest --upgrade
 
 # Force reinstall all components
-npx cc-orchestrator --force
+npx cc-orchestrator@latest --force
 ```
 
 ## After Installation
@@ -41,13 +42,15 @@ npx cc-orchestrator --force
 
 ```bash
 # Option 1: Use npx
-npx cc-orchestrator --upgrade
+npx cc-orchestrator@latest --upgrade
 
 # Option 2: Use npm script
-cd ~/.cc-orchestratorestrator
+cd ~/.cc-orchestrator
 npm run update
 ```
 
+`npm run update` checks the npm registry for the latest installer version, checks out the matching release tag, then runs `npm install` and `npm run setup -- --yes`.
+
 ## Requirements
 
 - Node.js >= 18.0.0

package/index.js

@@ -15,9 +15,26 @@ import * as path from 'path';
 import * as os from 'os';
 import * as readline from 'readline';
 import { execSync, spawn } from 'child_process';
+import { fileURLToPath } from 'url';
+import {
+  buildCloneCommand,
+  buildRemoteTagCheckCommand,
+  getMissingReleaseTagErrorMessage,
+  getReleaseTag,
+  runExistingInstallUpgradeWorkflow,
+  runFreshInstallWorkflow,
+} from './lib/release-target.js';
+import { classifyInstallTarget, resolveInstallTargetAction } from './lib/install-target.js';
 
 const REPO_URL = 'https://github.com/zhsks311/cc-orchestrator.git';
 const DEFAULT_INSTALL_DIR = path.join(os.homedir(), '.cc-orchestrator');
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+const installerPackageJson = JSON.parse(
+  fs.readFileSync(path.join(__dirname, 'package.json'), 'utf8')
+);
+const INSTALLER_VERSION = installerPackageJson.version;
+const RELEASE_TAG = getReleaseTag(INSTALLER_VERSION);
 
 // Parse arguments
 const args = process.argv.slice(2);
@@ -27,7 +44,7 @@ const forceMode = args.includes('--force') || args.includes('-f');
 const keysMode = args.includes('--keys') || args.includes('-k');
 
 // Get custom directory from args (first non-flag arg)
-const customDir = args.find(arg => !arg.startsWith('-'));
+const customDir = args.find((arg) => !arg.startsWith('-'));
 
 function printBanner() {
   console.log(`
@@ -91,6 +108,41 @@ function exec(cmd, options = {}) {
   execSync(cmd, { stdio: 'inherit', ...options });
 }
 
+function ensureRemoteReleaseTagExists(releaseTag) {
+  try {
+    execSync(buildRemoteTagCheckCommand(REPO_URL, releaseTag), {
+      stdio: ['ignore', 'pipe', 'pipe'],
+    });
+  } catch (error) {
+    if (error?.status === 2) {
+      throw new Error(getMissingReleaseTagErrorMessage(releaseTag));
+    }
+
+    throw error;
+  }
+}
+
+function readPackageJsonName(installDir) {
+  try {
+    const packageJson = JSON.parse(fs.readFileSync(path.join(installDir, 'package.json'), 'utf8'));
+    return typeof packageJson?.name === 'string' ? packageJson.name : null;
+  } catch {
+    return null;
+  }
+}
+
+function readRemoteOriginUrl(installDir) {
+  try {
+    return execSync('git config --get remote.origin.url', {
+      cwd: installDir,
+      encoding: 'utf8',
+      stdio: ['ignore', 'pipe', 'pipe'],
+    }).trim();
+  } catch {
+    return null;
+  }
+}
+
 function spawnAsync(cmd, args, options = {}) {
   return new Promise((resolve, reject) => {
     const proc = spawn(cmd, args, { stdio: 'inherit', shell: true, ...options });
@@ -105,33 +157,63 @@ function spawnAsync(cmd, args, options = {}) {
 async function install(installDir) {
   console.log(`\n📁 Install path: ${installDir}\n`);
 
-  // Check if directory exists
-  if (fs.existsSync(installDir)) {
-    if (upgradeMode) {
+  const installDirExists = fs.existsSync(installDir);
+  const installTarget = classifyInstallTarget({
+    installDirExists,
+    gitDirExists: fs.existsSync(path.join(installDir, '.git')),
+    remoteOriginUrl: installDirExists ? readRemoteOriginUrl(installDir) : null,
+    packageJsonName: installDirExists ? readPackageJsonName(installDir) : null,
+  });
+  const installAction = resolveInstallTargetAction({ installTarget, upgradeMode });
+
+  if (installDirExists) {
+    if (installAction.action === 'upgrade_existing') {
       console.log('📦 Existing installation found - upgrade mode\n');
-    } else {
+    } else if (installAction.confirmation === 'managed_overwrite') {
       const answer = await question('⚠️  Already installed. Overwrite? (y/N): ');
       if (answer.toLowerCase() !== 'y') {
         console.log('\nInstallation cancelled.');
         console.log('To upgrade: npx cc-orchestrator@latest --upgrade\n');
         process.exit(0);
       }
+    } else if (installAction.confirmation === 'explicit_delete') {
+      const answer = await question(
+        '⚠️  Existing directory is not managed by CC Orchestrator and will be deleted. Type DELETE to continue: '
+      );
+      if (answer !== 'DELETE') {
+        console.log('\nInstallation cancelled.');
+        console.log('To upgrade: npx cc-orchestrator@latest --upgrade\n');
+        process.exit(0);
+      }
     }
   }
 
+  if (installAction.action === 'abort_foreign_git') {
+    throw new Error(
+      'This directory is a git repository that is not managed by CC Orchestrator. Refusing to delete it.'
+    );
+  }
+
   // Step 1: Clone or pull
   console.log('─'.repeat(50));
-  if (fs.existsSync(path.join(installDir, '.git'))) {
-    console.log('\n[1/3] Fetching latest code...\n');
-    // Use fetch + reset to handle local changes (e.g., package-lock.json from npm install)
-    exec('git fetch origin main', { cwd: installDir });
-    exec('git reset --hard origin/main', { cwd: installDir });
+  if (installAction.action === 'upgrade_existing') {
+    console.log(`\n[1/3] Checking out release ${RELEASE_TAG}...\n`);
+    runExistingInstallUpgradeWorkflow({
+      releaseTag: RELEASE_TAG,
+      runCommand: (command) => {
+        exec(command, { cwd: installDir });
+      },
+    });
   } else {
-    console.log('\n[1/3] Cloning repository...\n');
-    if (fs.existsSync(installDir)) {
-      fs.rmSync(installDir, { recursive: true, force: true });
-    }
-    exec(`git clone ${REPO_URL} "${installDir}"`);
+    console.log(`\n[1/3] Cloning release ${RELEASE_TAG}...\n`);
+    await runFreshInstallWorkflow({
+      installDirExists,
+      ensureRemoteReleaseTagExists: () => ensureRemoteReleaseTagExists(RELEASE_TAG),
+      removeExistingInstallDir: () => {
+        fs.rmSync(installDir, { recursive: true, force: true });
+      },
+      cloneRelease: () => exec(buildCloneCommand(REPO_URL, installDir, RELEASE_TAG)),
+    });
   }
 
   // Step 2: npm install
@@ -196,9 +278,7 @@ async function main() {
   }
 
   // Determine install directory
-  const installDir = customDir
-    ? path.resolve(customDir)
-    : DEFAULT_INSTALL_DIR;
+  const installDir = customDir ? path.resolve(customDir) : DEFAULT_INSTALL_DIR;
 
   await install(installDir);
 }

package/lib/install-target.js

@@ -0,0 +1,94 @@
+const MANAGED_REPO_SLUG = 'zhsks311/cc-orchestrator';
+const MANAGED_PACKAGE_NAME = 'cc-orchestrator-server';
+
+function stripGitSuffix(value) {
+  return value.replace(/\.git$/i, '').replace(/\/+$/u, '');
+}
+
+function parseGitHubSlug(remoteOriginUrl) {
+  if (typeof remoteOriginUrl !== 'string') {
+    return null;
+  }
+
+  const trimmed = remoteOriginUrl.trim();
+  if (!trimmed) {
+    return null;
+  }
+
+  if (trimmed.startsWith('git@github.com:')) {
+    return stripGitSuffix(trimmed.slice('git@github.com:'.length));
+  }
+
+  try {
+    const parsed = new URL(trimmed);
+    if (parsed.hostname !== 'github.com') {
+      return null;
+    }
+
+    return stripGitSuffix(parsed.pathname.replace(/^\/+/u, ''));
+  } catch {
+    return null;
+  }
+}
+
+export function isManagedInstallRemoteUrl(remoteOriginUrl) {
+  return parseGitHubSlug(remoteOriginUrl) === MANAGED_REPO_SLUG;
+}
+
+export function classifyInstallTarget({
+  installDirExists,
+  gitDirExists = false,
+  remoteOriginUrl,
+  packageJsonName,
+}) {
+  if (!installDirExists) {
+    return 'missing';
+  }
+
+  if (!gitDirExists) {
+    return 'foreign_directory';
+  }
+
+  if (isManagedInstallRemoteUrl(remoteOriginUrl) && packageJsonName === MANAGED_PACKAGE_NAME) {
+    return 'managed_install';
+  }
+
+  return 'foreign_git';
+}
+
+export function resolveInstallTargetAction({ installTarget, upgradeMode }) {
+  if (upgradeMode && installTarget !== 'managed_install') {
+    throw new Error('Upgrade mode is only supported for verified CC Orchestrator installations.');
+  }
+
+  if (installTarget === 'missing') {
+    return {
+      action: 'fresh_install',
+      confirmation: 'none',
+    };
+  }
+
+  if (installTarget === 'managed_install') {
+    return upgradeMode
+      ? {
+          action: 'upgrade_existing',
+          confirmation: 'none',
+        }
+      : {
+          action: 'fresh_install',
+          confirmation: 'managed_overwrite',
+        };
+  }
+
+  if (installTarget === 'foreign_directory') {
+    return {
+      action: 'fresh_install',
+      confirmation: 'explicit_delete',
+    };
+  }
+
+  return {
+    action: 'abort_foreign_git',
+    confirmation: 'none',
+  };
+}

package/lib/release-target.js

@@ -0,0 +1,137 @@
+export function ensureTagPrefix(value) {
+  return value.startsWith('v') ? value : `v${value}`;
+}
+
+export function getReleaseTag(version) {
+  return ensureTagPrefix(version.trim());
+}
+
+export function buildCloneCommand(repoUrl, installDir, releaseTag) {
+  return `git clone --branch ${releaseTag} --depth 1 ${repoUrl} "${installDir}"`;
+}
+
+export function buildRemoteTagCheckCommand(repoUrl, releaseTag) {
+  return `git ls-remote --exit-code --tags ${repoUrl} refs/tags/${releaseTag}`;
+}
+
+export function getMissingReleaseTagErrorMessage(releaseTag) {
+  return `Release tag ${releaseTag} is not available yet. Retry after the release publish finishes.`;
+}
+
+export async function runFreshInstallWorkflow({
+  installDirExists,
+  ensureRemoteReleaseTagExists,
+  removeExistingInstallDir,
+  cloneRelease,
+}) {
+  await ensureRemoteReleaseTagExists();
+
+  if (installDirExists) {
+    removeExistingInstallDir();
+  }
+
+  await cloneRelease();
+}
+
+function buildUpgradeCommandPlan(releaseTag) {
+  return {
+    fetchTags: 'git fetch --tags origin',
+    verifyReleaseTag: `git rev-parse -q --verify refs/tags/${releaseTag}`,
+    checkoutRelease: `git checkout --force ${releaseTag}`,
+    resetRelease: `git reset --hard ${releaseTag}`,
+  };
+}
+
+export function buildUpgradeCommands(releaseTag) {
+  const plan = buildUpgradeCommandPlan(releaseTag);
+  return [plan.fetchTags, plan.verifyReleaseTag, plan.checkoutRelease, plan.resetRelease];
+}
+
+export function runExistingInstallUpgradeWorkflow({ releaseTag, runCommand }) {
+  const plan = buildUpgradeCommandPlan(releaseTag);
+
+  runCommand(plan.fetchTags);
+
+  try {
+    runCommand(plan.verifyReleaseTag);
+  } catch {
+    throw new Error(getMissingReleaseTagErrorMessage(releaseTag));
+  }
+
+  runCommand(plan.checkoutRelease);
+  runCommand(plan.resetRelease);
+}
+
+export function buildSetupCommand() {
+  return 'npm run setup -- --yes';
+}
+
+export function buildReleaseCommitRef(releaseTag) {
+  return `refs/tags/${releaseTag}^{commit}`;
+}
+
+export function buildReleaseCommitLookupArgs(releaseTag) {
+  return ['rev-parse', buildReleaseCommitRef(releaseTag)];
+}
+
+export function getLatestVersionTag(tags) {
+  if (!Array.isArray(tags) || tags.length === 0) {
+    return null;
+  }
+
+  return (
+    [...tags]
+      .filter((tag) => /^v\d+\.\d+\.\d+$/.test(tag))
+      .sort((left, right) => right.localeCompare(left, undefined, { numeric: true }))[0] ?? null
+  );
+}
+
+export function getLatestVersionTagFromOutput(output) {
+  if (typeof output !== 'string') {
+    return null;
+  }
+
+  return getLatestVersionTag(output.split('\n').map((line) => line.trim()).filter(Boolean));
+}
+
+export function getLatestVersionTagFromRemoteRefsOutput(output) {
+  if (typeof output !== 'string') {
+    return null;
+  }
+
+  const tags = output
+    .split('\n')
+    .map((line) => line.trim())
+    .filter(Boolean)
+    .map((line) => line.split('\t')[1] ?? '')
+    .filter((ref) => ref.startsWith('refs/tags/'))
+    .map((ref) => ref.replace('refs/tags/', ''));
+
+  return getLatestVersionTag(tags);
+}
+
+export function getLatestPublishedInstallerReleaseTagFromOutput(output) {
+  if (typeof output !== 'string') {
+    return null;
+  }
+
+  const trimmed = output.trim();
+  if (!trimmed) {
+    return null;
+  }
+
+  try {
+    const parsed = JSON.parse(trimmed);
+    if (typeof parsed === 'string' && parsed.trim()) {
+      return getReleaseTag(parsed);
+    }
+  } catch {
+    return null;
+  }
+
+  return null;
+}
+
+export function isReleaseCheckoutUpToDate(localCommit, releaseCommit) {
+  return Boolean(localCommit && releaseCommit && localCommit === releaseCommit);
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "cc-orchestrator",
-  "version": "0.2.7",
+  "version": "0.2.9",
   "description": "CLI to install CC Orchestrator - Multi-model orchestration for Claude Code",
   "bin": {
     "cc-orchestrator": "./index.js"