@4pm/cli 0.3.0 → 0.3.2

package/dist/index.js

@@ -3725,18 +3725,41 @@ import {
   chmodSync,
   existsSync as existsSync2,
   readFileSync as readFileSync2,
-  rmSync,
+  rmSync as rmSync2,
   writeFileSync as writeFileSync2
 } from "fs";
 import { homedir as homedir2 } from "os";
 import { join as join2 } from "path";
 
 // src/config/profile.ts
-import { existsSync, mkdirSync, readFileSync, writeFileSync } from "fs";
+import { existsSync, mkdirSync, readFileSync, rmSync, writeFileSync } from "fs";
 import { homedir } from "os";
 import { join } from "path";
 var DEFAULT_PROFILE = "default";
-function resolveProfile(args) {
+function defaultPointerPath() {
+  return join(homedir(), ".4pm", "default");
+}
+function defaultProfileName() {
+  try {
+    const userId = readFileSync(defaultPointerPath(), "utf8").trim();
+    if (userId) return userId;
+  } catch {
+  }
+  return DEFAULT_PROFILE;
+}
+function writeDefaultProfile(userId) {
+  mkdirSync(join(homedir(), ".4pm"), { recursive: true });
+  writeFileSync(defaultPointerPath(), userId, "utf8");
+}
+function clearDefaultProfileIf(name) {
+  try {
+    if (readFileSync(defaultPointerPath(), "utf8").trim() === name) {
+      rmSync(defaultPointerPath(), { force: true });
+    }
+  } catch {
+  }
+}
+function resolveProfileArg(args) {
   const index = args.indexOf("--profile");
   if (index >= 0) {
     const name = args[index + 1];
@@ -3746,7 +3769,7 @@ function resolveProfile(args) {
     const rest = [...args.slice(0, index), ...args.slice(index + 2)];
     return [name, rest];
   }
-  return [process.env.FOURPM_PROFILE ?? DEFAULT_PROFILE, args];
+  return [process.env.FOURPM_PROFILE ?? null, args];
 }
 function profileDir(name) {
   const dir = join(homedir(), ".4pm", "profiles", name);
@@ -3777,7 +3800,7 @@ function readCredential(profileDir2, profileName) {
           readFileSync2(LEGACY_CRE_PATH, "utf8")
         );
         writeCredential(profileDir2, legacy);
-        rmSync(LEGACY_CRE_PATH, { force: true });
+        rmSync2(LEGACY_CRE_PATH, { force: true });
         return legacy;
       } catch {
         return null;
@@ -3797,7 +3820,7 @@ function writeCredential(profileDir2, credential) {
   chmodSync(path, 384);
 }
 function deleteCredential(profileDir2) {
-  rmSync(credentialPath(profileDir2), { force: true });
+  rmSync2(credentialPath(profileDir2), { force: true });
 }
 
 // src/core/fingerprint.ts
@@ -3884,15 +3907,17 @@ async function fetchCliVersion(serverUrl) {
 }
 
 // src/commands/link.ts
-async function runLink(serverUrl, profileDir2, profileName) {
-  if (readCredential(profileDir2, profileName)) {
+async function runLink(serverUrl, explicitProfile) {
+  const currentName = explicitProfile ?? defaultProfileName();
+  if (readCredential(profileDir(currentName), currentName)) {
+    const flag = explicitProfile ? ` --profile ${explicitProfile}` : "";
     console.log(
-      `Profile "${profileName}" is already linked (.cre). Run \`4pm unlink --profile ${profileName}\` first if you want to pair again.`
+      `Profile "${currentName}" is already linked (.cre). Run \`4pm unlink${flag}\` first if you want to pair again.`
     );
     return;
   }
   const hashcode1 = randomBytes(32).toString("hex");
-  console.log(`\u2500\u2500 4PM cli pairing (profile: ${profileName}) \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500`);
+  console.log(`\u2500\u2500 4PM cli pairing (profile: ${explicitProfile ?? "default"}) \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500`);
   console.log("1. Open the 4PM web \u2192 /machines, enter hashcode (1):");
   console.log(`
    ${hashcode1}
@@ -3901,26 +3926,35 @@ async function runLink(serverUrl, profileDir2, profileName) {
   const rl = createInterface({ input: process.stdin, output: process.stdout });
   const hashcode2 = (await rl.question("hashcode (2): ")).trim();
   rl.close();
-  const { hashcode3 } = await confirmPairing(serverUrl, hashcode2, collectFingerprint());
-  writeCredential(profileDir2, {
+  const { hashcode3, userId, username } = await confirmPairing(
+    serverUrl,
+    hashcode2,
+    collectFingerprint()
+  );
+  const profileName = explicitProfile ?? userId;
+  writeCredential(profileDir(profileName), {
     serverUrl,
     hashcode3,
     scope: "unknown",
     // scope is decided by the server based on the pairing user (ADR-0010)
     pairedAt: (/* @__PURE__ */ new Date()).toISOString()
   });
-  console.log("\u2714 Linked successfully \u2014 saved .cre. Run `4pm start` to connect.");
+  if (!explicitProfile) writeDefaultProfile(userId);
+  console.log(
+    `\u2714 Linked successfully as "${username}" \u2014 saved .cre. Run \`4pm start\` to connect.`
+  );
 }
 
 // src/commands/start.ts
 import { spawn as spawn2 } from "child_process";
+import { join as join9 } from "path";
 
 // src/core/update.ts
 import { execSync as execSync2 } from "child_process";
 import { createHash as createHash2, createPublicKey, verify } from "crypto";
-import { mkdtempSync, writeFileSync as writeFileSync3 } from "fs";
+import { mkdtempSync, readFileSync as readFileSync5, writeFileSync as writeFileSync3 } from "fs";
 import { tmpdir } from "os";
-import { dirname, join as join3, sep } from "path";
+import { dirname as dirname2, join as join4, sep } from "path";
 
 // src/config/signing.ts
 var CLI_SIGNING_PUBLIC_KEY = `
@@ -3930,7 +3964,19 @@ MCowBQYDK2VwAyEARlfzjaFhe5bhRrMp/ZuH6sVqg/S7f8B1dliuF21iDTw=
 `;
 
 // src/version.ts
-var CLI_VERSION = "0.3.0";
+import { readFileSync as readFileSync4 } from "fs";
+import { dirname, join as join3 } from "path";
+import { fileURLToPath } from "url";
+function readCliVersion() {
+  try {
+    const here = dirname(fileURLToPath(import.meta.url));
+    const pkg = JSON.parse(readFileSync4(join3(here, "..", "package.json"), "utf8"));
+    return pkg.version ?? "0.0.0";
+  } catch {
+    return "0.0.0";
+  }
+}
+var CLI_VERSION = readCliVersion();
 
 // src/core/update.ts
 function compareSemver(a, b) {
@@ -3945,6 +3991,14 @@ function compareSemver(a, b) {
 function installedViaNpm() {
   return (process.argv[1] ?? "").split(sep).includes("node_modules");
 }
+function readInstalledVersion() {
+  try {
+    const pkgPath = join4(dirname2(dirname2(process.argv[1] ?? ".")), "package.json");
+    return JSON.parse(readFileSync5(pkgPath, "utf8")).version ?? "0.0.0";
+  } catch {
+    return "0.0.0";
+  }
+}
 function updateViaNpm(version) {
   execSync2(`npm i -g @4pm/cli@${version}`, { stdio: "inherit" });
 }
@@ -3971,9 +4025,9 @@ async function updateViaDownload(tarballUrl, checksum, signature) {
       throw new Error("Invalid tarball signature \u2014 aborting update (ADR-0015).");
     }
   }
-  const tmp = join3(mkdtempSync(join3(tmpdir(), "4pm-update-")), "cli.tgz");
+  const tmp = join4(mkdtempSync(join4(tmpdir(), "4pm-update-")), "cli.tgz");
   writeFileSync3(tmp, buf);
-  const installRoot = dirname(dirname(process.argv[1] ?? "."));
+  const installRoot = dirname2(dirname2(process.argv[1] ?? "."));
   execSync2(`tar -xzf "${tmp}" -C "${installRoot}" --strip-components=1`, {
     stdio: "inherit"
   });
@@ -4000,6 +4054,7 @@ async function updateToLatest(serverUrl) {
   }
 }
 async function checkAndUpdate(serverUrl, autoUpdate) {
+  if (CLI_VERSION.startsWith("0.0.0")) return { action: "none" };
   let meta;
   try {
     meta = await fetchCliVersion(serverUrl);
@@ -4029,7 +4084,6 @@ async function checkAndUpdate(serverUrl, autoUpdate) {
         meta.source.signature
       );
     }
-    return { action: "updated", version: meta.latest };
   } catch (err) {
     if (mandatory) {
       console.error(`Update failed: ${err}`);
@@ -4038,6 +4092,17 @@ async function checkAndUpdate(serverUrl, autoUpdate) {
     console.warn(`Update failed (skipping \u2014 not mandatory): ${err}`);
     return { action: "none" };
   }
+  const installed = readInstalledVersion();
+  if (compareSemver(installed, meta.latest) < 0) {
+    const msg = `Update reported success but the installed version is still ${installed} (expected ${meta.latest}) \u2014 it did not apply to the running install (check the global npm prefix vs the running binary).`;
+    if (mandatory) {
+      console.error(msg);
+      return { action: "blocked", minSupported: meta.minSupported };
+    }
+    console.warn(`${msg} Skipping restart.`);
+    return { action: "none" };
+  }
+  return { action: "updated", version: meta.latest };
 }
 
 // src/core/ws-client.ts
@@ -4074,6 +4139,7 @@ var Role = {
 };
 var ALL_ROLES = Object.values(Role);
 var EXCLUSIVE_ROLES = [Role.ADMIN, Role.MACHINE];
+var PM_GRANTABLE_ROLES = [Role.SA_SE, Role.QA, Role.BA];
 
 // ../../22-packages/11-shared/11-constants/src/permissions.ts
 var PermissionCode = {
@@ -4260,6 +4326,13 @@ var SELF_SERVICE_CODES = [
   P.USER_READ_SELF,
   P.NOTIFICATION_READ
 ];
+var ADMIN_ONLY_CODES = [
+  P.ORG_READ,
+  P.ORG_UPDATE,
+  P.ORG_DELETE,
+  P.BILLING_READ,
+  P.BILLING_MANAGE
+];
 var TEAM_GRANTABLE_CODES = [
   P.TEAM_READ,
   P.TEAM_UPDATE,
@@ -4302,10 +4375,11 @@ var PROJECT_GRANTABLE_CODES = [
   P.MACHINE_PHYSIC_MANAGE
 ];
 var SELF_SERVICE_SET = new Set(SELF_SERVICE_CODES);
+var ADMIN_ONLY_SET = new Set(ADMIN_ONLY_CODES);
 var TEAM_GRANTABLE_SET = new Set(TEAM_GRANTABLE_CODES);
 var PROJECT_GRANTABLE_SET = new Set(PROJECT_GRANTABLE_CODES);
 function grantSubjectsFor(code) {
-  if (SELF_SERVICE_SET.has(code)) return [];
+  if (SELF_SERVICE_SET.has(code) || ADMIN_ONLY_SET.has(code)) return [];
   const subjects = [GrantSubjectType.USER];
   if (TEAM_GRANTABLE_SET.has(code)) subjects.push(GrantSubjectType.TEAM);
   if (PROJECT_GRANTABLE_SET.has(code)) subjects.push(GrantSubjectType.PROJECT);
@@ -4586,8 +4660,8 @@ ${JSON.stringify(req.spec)}`;
 }
 
 // src/core/command-history.ts
-import { existsSync as existsSync4, readFileSync as readFileSync4, writeFileSync as writeFileSync4 } from "fs";
-import { join as join4 } from "path";
+import { existsSync as existsSync4, readFileSync as readFileSync6, writeFileSync as writeFileSync4 } from "fs";
+import { join as join5 } from "path";
 var MAX_ENTRIES = 1e3;
 var filePath = null;
 var entries = [];
@@ -4649,10 +4723,10 @@ async function uploadHistory(cfg) {
   }
 }
 function initCommandHistory(profileDir2, profileName, uploadMinutes = 10) {
-  filePath = join4(profileDir2, "command-history.json");
+  filePath = join5(profileDir2, "command-history.json");
   if (existsSync4(filePath)) {
     try {
-      entries = JSON.parse(readFileSync4(filePath, "utf8"));
+      entries = JSON.parse(readFileSync6(filePath, "utf8"));
     } catch {
       entries = [];
     }
@@ -4725,12 +4799,12 @@ async function readWorkerFile(path) {
 // src/core/git-diff.ts
 import { readFile as readFile2 } from "fs/promises";
 import { execFile as execFile2 } from "child_process";
-import { basename, dirname as dirname2, resolve as resolve3 } from "path";
+import { basename, dirname as dirname3, resolve as resolve3 } from "path";
 import { promisify as promisify2 } from "util";
 var run2 = promisify2(execFile2);
 async function gitDiff(path) {
   const target = resolve3(path);
-  const dir = dirname2(target);
+  const dir = dirname3(target);
   const base = basename(target);
   let newContent = "";
   try {
@@ -4784,13 +4858,13 @@ ${stderr}`;
 // src/core/scaffold.ts
 import { cp, mkdir, writeFile } from "fs/promises";
 import { execFile as execFile4 } from "child_process";
-import { dirname as dirname3, join as join5, resolve as resolve4 } from "path";
-import { fileURLToPath } from "url";
+import { dirname as dirname4, join as join6, resolve as resolve4 } from "path";
+import { fileURLToPath as fileURLToPath2 } from "url";
 import { promisify as promisify4 } from "util";
 var run4 = promisify4(execFile4);
 function sampleDir() {
   if (process.env.SCAFFOLD_SAMPLE_DIR) return process.env.SCAFFOLD_SAMPLE_DIR;
-  const here = dirname3(fileURLToPath(import.meta.url));
+  const here = dirname4(fileURLToPath2(import.meta.url));
   return resolve4(here, "../../project-sample");
 }
 async function scaffoldProject(payload, onProgress) {
@@ -4803,7 +4877,7 @@ async function scaffoldProject(payload, onProgress) {
     if (payload.spec) {
       emit("spec", "Writing project.spec.json\u2026");
       await writeFile(
-        join5(target, "project.spec.json"),
+        join6(target, "project.spec.json"),
         JSON.stringify(payload.spec, null, 2),
         "utf8"
       );
@@ -4833,6 +4907,72 @@ async function addProject(payload, onProgress) {
   }
 }
 
+// src/common/logger/logger.ts
+import { appendFile, mkdir as mkdir2, readdir as readdir2, unlink } from "fs/promises";
+import { join as join7 } from "path";
+var LEVEL_ORDER = { error: 0, warn: 1, info: 2, debug: 3 };
+var DAY_MS = 24 * 60 * 60 * 1e3;
+var DEFAULT_RETENTION_DAYS = 14;
+var CliLogger = class {
+  dir = null;
+  minLevel = "info";
+  base = null;
+  retentionDays = DEFAULT_RETENTION_DAYS;
+  queue = Promise.resolve();
+  /** Wire the profile log dir + level + base context; runs a retention sweep. */
+  configure(opts) {
+    this.dir = opts.dir;
+    this.minLevel = opts.level;
+    this.base = opts.base;
+    this.retentionDays = opts.retentionDays ?? DEFAULT_RETENTION_DAYS;
+    void this.cleanupOldLogs();
+  }
+  /** Log an error-level event. */
+  error(event, fields) {
+    this.write("error", event, fields);
+  }
+  /** Log a warn-level event. */
+  warn(event, fields) {
+    this.write("warn", event, fields);
+  }
+  /** Log an info-level event. */
+  info(event, fields) {
+    this.write("info", event, fields);
+  }
+  /** Log a debug-level event. */
+  debug(event, fields) {
+    this.write("debug", event, fields);
+  }
+  /** Serialize one JSONL line into today's file (no-op until configured / below level). */
+  write(level, event, fields) {
+    const dir = this.dir;
+    if (!dir || !this.base) return;
+    if (LEVEL_ORDER[level] > LEVEL_ORDER[this.minLevel]) return;
+    const timestamp = (/* @__PURE__ */ new Date()).toISOString();
+    const entry = { timestamp, level, ...this.base, event, ...fields };
+    const line = JSON.stringify(entry) + "\n";
+    const path = join7(dir, `cli-${timestamp.slice(0, 10)}.jsonl`);
+    this.queue = this.queue.then(() => mkdir2(dir, { recursive: true })).then(() => appendFile(path, line, "utf8")).catch((err) => {
+      console.warn(`Failed to write cli log: ${err}`);
+    });
+  }
+  /** Delete cli log files older than the retention window (best-effort). */
+  async cleanupOldLogs() {
+    const dir = this.dir;
+    if (!dir) return;
+    const files = await readdir2(dir).catch(() => []);
+    const cutoff = Date.now() - this.retentionDays * DAY_MS;
+    for (const file of files) {
+      const match = /^cli-(\d{4}-\d{2}-\d{2})\.jsonl$/.exec(file);
+      if (!match) continue;
+      if ((/* @__PURE__ */ new Date(`${match[1]}T00:00:00Z`)).getTime() < cutoff) {
+        await unlink(join7(dir, file)).catch(() => void 0);
+      }
+    }
+  }
+};
+var logger = new CliLogger();
+
 // src/core/ws-client.ts
 var HEARTBEAT_MS = 3e4;
 var MAX_HASHCODE_INVALID_RETRIES = 5;
@@ -4889,6 +5029,7 @@ var WsClient = class {
       }
       if (this.stopped) return;
       const wait = backoffJitterMs(Math.min(attempt, 6), 1e3, 6e4);
+      logger.info("ws.reconnect", { attempt, waitMs: wait });
       console.log(`Reconnecting in ${Math.round(wait / 1e3)}s\u2026`);
       await sleep(wait);
     }
@@ -4927,6 +5068,7 @@ var WsClient = class {
         socket.on("close", (code) => {
           this.clearHeartbeat();
           this.sessionKey = null;
+          logger.debug("ws.close", { code });
           if (code === CLOSE_DRAINING) {
             console.log("Server draining \u2014 will reconnect (backoff + jitter).");
           }
@@ -4946,6 +5088,7 @@ var WsClient = class {
     if ("type" in message) {
       if (message.type === "hello_ack" && this.ecdh) {
         this.sessionKey = deriveSessionKey(this.ecdh, message.pubkey);
+        logger.info("ws.connected", { version: CLI_VERSION });
         console.log("\u2714 Connected to the server (session encryption ready).");
         this.sendMachineStatus();
         this.flushOfflineBuffer();
@@ -4953,6 +5096,7 @@ var WsClient = class {
         return;
       }
       if (message.type === "error") {
+        logger.warn("ws.error", { errorCode: message.errorCode });
         if (["LINK_REVOKED", "HASHCODE_EXPIRED"].includes(message.errorCode)) {
           this.logout(message.errorCode);
           return;
@@ -4963,6 +5107,14 @@ var WsClient = class {
           this.socket?.close();
           return;
         }
+        if (message.errorCode === "SESSION_REPLACED") {
+          this.stopped = true;
+          console.error(
+            "Another session for this profile took over \u2014 this instance is stopping. (Are you running `4pm start` twice for the same profile?)"
+          );
+          this.socket?.close();
+          return;
+        }
         console.warn(`Server reported an error: ${message.errorCode}`);
         this.socket?.close();
         return;
@@ -4987,6 +5139,10 @@ var WsClient = class {
     switch (message.channel) {
       case WsChannels.COMMAND_DISPATCH: {
         const dispatch = payload;
+        logger.info("command.dispatch", {
+          commandId: dispatch.commandId,
+          cmd: dispatch.cmd
+        });
         recordCommand({
           commandId: dispatch.commandId,
           projectId: dispatch.projectId,
@@ -5161,12 +5317,54 @@ var WsClient = class {
     this.stopped = true;
     this.clearHeartbeat();
     this.socket?.close();
+    logger.warn("ws.logout", { reason });
     deleteCredential(this.context.profileDir);
     console.error(`Link is no longer valid (${reason}) \u2014 deleted .cre. Run \`4pm link\` to pair again.`);
   }
 };
 
+// src/core/instance-lock.ts
+import { readFileSync as readFileSync7, rmSync as rmSync3, writeFileSync as writeFileSync5 } from "fs";
+import { join as join8 } from "path";
+function lockPath(profileDir2) {
+  return join8(profileDir2, "start.lock");
+}
+function isAlive(pid) {
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch (err) {
+    return err.code === "EPERM";
+  }
+}
+function lockHolder(profileDir2) {
+  try {
+    const pid = Number.parseInt(readFileSync7(lockPath(profileDir2), "utf8").trim(), 10);
+    if (Number.isInteger(pid) && pid > 0 && isAlive(pid)) return pid;
+  } catch {
+  }
+  return null;
+}
+function acquireInstanceLock(profileDir2) {
+  if (lockHolder(profileDir2) !== null) return false;
+  writeFileSync5(lockPath(profileDir2), String(process.pid), "utf8");
+  return true;
+}
+function releaseInstanceLock(profileDir2) {
+  try {
+    const pid = Number.parseInt(readFileSync7(lockPath(profileDir2), "utf8").trim(), 10);
+    if (pid === process.pid) rmSync3(lockPath(profileDir2), { force: true });
+  } catch {
+  }
+}
+
 // src/commands/start.ts
+function resolveLogLevel() {
+  if (process.argv.includes("--verbose")) return "debug";
+  const env = process.env.FOURPM_LOG_LEVEL;
+  if (env === "error" || env === "warn" || env === "info" || env === "debug") return env;
+  return "info";
+}
 async function runStart(profileDir2, profileName) {
   const credential = readCredential(profileDir2, profileName);
   if (!credential) {
@@ -5176,10 +5374,17 @@ async function runStart(profileDir2, profileName) {
     process.exitCode = 1;
     return;
   }
+  logger.configure({
+    dir: join9(profileDir2, "logs"),
+    level: resolveLogLevel(),
+    base: { version: CLI_VERSION, profile: profileName, scope: credential.scope }
+  });
+  logger.info("cli.start", { serverUrl: credential.serverUrl });
   const config = readProfileConfig(profileDir2);
   const autoUpdate = config.autoUpdate !== false && process.env.FOURPM_NO_UPDATE !== "1";
   const result = await checkAndUpdate(credential.serverUrl, autoUpdate);
   if (result.action === "blocked") {
+    logger.error("update.blocked", { minSupported: result.minSupported });
     console.error(
       `CLI is older than minSupported (${result.minSupported}) and the update failed \u2014 cannot connect.`
     );
@@ -5187,6 +5392,7 @@ async function runStart(profileDir2, profileName) {
     return;
   }
   if (result.action === "updated") {
+    logger.info("update.updated", { version: result.version });
     console.log("Restarting with the new version\u2026");
     const child = spawn2(process.execPath, process.argv.slice(1), {
       stdio: "inherit",
@@ -5195,13 +5401,28 @@ async function runStart(profileDir2, profileName) {
     child.on("exit", (code) => process.exit(code ?? 0));
     return;
   }
-  initCommandHistory(profileDir2, profileName, config.commandHistoryUploadMinutes ?? 10);
-  console.log(`Connecting to ${credential.serverUrl} (profile: ${profileName})\u2026`);
-  await new WsClient({
-    credential,
-    machine: collectFingerprint(),
-    profileDir: profileDir2
-  }).run();
+  if (!acquireInstanceLock(profileDir2)) {
+    console.error(
+      `Profile "${profileName}" is already running (pid ${lockHolder(profileDir2)}). Only one \`4pm start\` per profile is allowed.`
+    );
+    process.exitCode = 1;
+    return;
+  }
+  const release = () => releaseInstanceLock(profileDir2);
+  process.once("exit", release);
+  process.once("SIGINT", () => process.exit(0));
+  process.once("SIGTERM", () => process.exit(0));
+  try {
+    initCommandHistory(profileDir2, profileName, config.commandHistoryUploadMinutes ?? 10);
+    console.log(`Connecting to ${credential.serverUrl} (profile: ${profileName})\u2026`);
+    await new WsClient({
+      credential,
+      machine: collectFingerprint(),
+      profileDir: profileDir2
+    }).run();
+  } finally {
+    release();
+  }
 }
 
 // src/commands/unlink.ts
@@ -5211,6 +5432,7 @@ function runUnlink(profileDir2, profileName) {
     return;
   }
   deleteCredential(profileDir2);
+  clearDefaultProfileIf(profileName);
   console.log("\u2714 Deleted .cre \u2014 revoke the server-side link at web /machines.");
 }
 
@@ -5261,30 +5483,37 @@ function flagValue(args, name) {
   return index >= 0 ? args[index + 1] : void 0;
 }
 async function main() {
-  const [profileName, args] = resolveProfile(process.argv.slice(2));
+  const [explicitProfile, args] = resolveProfileArg(process.argv.slice(2));
   const [command, ...rest] = args;
-  const dir = profileDir(profileName);
   switch (command) {
     case "link": {
       const serverUrl = flagValue(rest, "server") ?? process.env.FOURPM_SERVER ?? "http://localhost:3001";
-      await runLink(serverUrl.replace(/\/$/, ""), dir, profileName);
+      await runLink(serverUrl.replace(/\/$/, ""), explicitProfile);
       break;
     }
-    case "start":
-      await runStart(dir, profileName);
+    case "start": {
+      const name = explicitProfile ?? defaultProfileName();
+      await runStart(profileDir(name), name);
       break;
-    case "unlink":
-      runUnlink(dir, profileName);
+    }
+    case "unlink": {
+      const name = explicitProfile ?? defaultProfileName();
+      runUnlink(profileDir(name), name);
       break;
+    }
     case "version":
     case "--version":
-    case "-v":
-      await runVersion(dir, profileName, flagValue(rest, "server"));
+    case "-v": {
+      const name = explicitProfile ?? defaultProfileName();
+      await runVersion(profileDir(name), name, flagValue(rest, "server"));
       break;
+    }
     case "update":
-    case "upgrade":
-      await runUpdate(dir, profileName, flagValue(rest, "server"));
+    case "upgrade": {
+      const name = explicitProfile ?? defaultProfileName();
+      await runUpdate(profileDir(name), name, flagValue(rest, "server"));
       break;
+    }
     default:
       console.log(
         [

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@4pm/cli",
-  "version": "0.3.0",
+  "version": "0.3.2",
   "private": false,
   "description": "4PM CLI — drives Claude/Codex CLIs on AI worker machines (Node + TypeScript)",
   "type": "module",