argsbarg 4.1.0 → 4.1.1

package/src/cli-tool/run-create.ts

@@ -0,0 +1,149 @@
+/** `argsbarg create` command orchestration. */
+
+import { mkdirSync } from "node:fs";
+import { relative, resolve } from "node:path";
+import {
+  applyCreate,
+  type CreateOptions,
+  classNameFromKey,
+  diffCreateDetails,
+  parseCreateArgv,
+  printCreateDiffs,
+  renderCreateTree,
+  resolveCreateOptions,
+} from "./create.ts";
+import { printPostCreatePlan, runPostCreate } from "./post-create.ts";
+import { promptConfirm, promptOptional, promptRequired } from "./prompt.ts";
+
+function isInteractiveTty(): boolean {
+  return Boolean(process.stdin.isTTY);
+}
+
+function collectInteractiveOptions(
+  partial: Partial<CreateOptions>,
+  dir: string,
+): { opts: CreateOptions; baseDir: string } {
+  process.stderr.write("Argsbarg create — bootstrap a new CLI from full-example\n\n");
+  const targetDir = promptOptional("Target directory", dir) ?? dir;
+  const baseDir = resolve(process.cwd(), targetDir);
+  const key = promptRequired("CLI key (binary name)", partial.key);
+  const className =
+    promptOptional("Formula class name", partial.className ?? classNameFromKey(key)) ??
+    classNameFromKey(key);
+  const releaseRepo =
+    promptOptional("GitHub release repo (org/repo)", partial.releaseRepo ?? `example/${key}`) ??
+    `example/${key}`;
+  const homepage =
+    promptOptional("Homepage URL", partial.homepage ?? `https://github.com/${releaseRepo}`) ??
+    `https://github.com/${releaseRepo}`;
+  const tap =
+    promptOptional("Homebrew tap (org/repo)", partial.tap ?? `local/${key}`) ?? `local/${key}`;
+  const desc =
+    promptOptional("Formula description", partial.desc ?? `${className} CLI`) ?? `${className} CLI`;
+
+  const opts = resolveCreateOptions(
+    {
+      ...partial,
+      key,
+      className,
+      tap,
+      homepage,
+      releaseRepo,
+      desc,
+      force: partial.force ?? false,
+    },
+    baseDir,
+  );
+
+  process.stderr.write(`\nTarget: ${baseDir}\n`);
+  process.stderr.write(`Key: ${opts.key}  Class: ${opts.className}  Tap: ${opts.tap}\n\n`);
+  const tree = renderCreateTree(opts);
+  process.stderr.write(`Files (${tree.size}):\n`);
+  for (const rel of [...tree.keys()].sort()) {
+    process.stderr.write(`  ${rel}\n`);
+  }
+  process.stderr.write("\n");
+  printPostCreatePlan();
+  process.stderr.write("\n");
+
+  if (!promptConfirm("Proceed")) {
+    throw new Error("Aborted.");
+  }
+
+  return { opts, baseDir };
+}
+
+export async function runCreate(input: Partial<CreateOptions> & { dir?: string }): Promise<number> {
+  try {
+    const baseDir = resolve(process.cwd(), input.dir ?? ".");
+    const partial = { ...input };
+    delete (partial as { dir?: string }).dir;
+
+    if (partial.check || partial.diff) {
+      const drifts = diffCreateDetails(baseDir, partial);
+      if (drifts.length > 0) {
+        process.stderr.write(`Create drift in ${baseDir}:\n`);
+        for (const d of drifts) process.stderr.write(`  ${d.rel}\n`);
+        if (partial.diff) printCreateDiffs(drifts, baseDir);
+        return 1;
+      }
+      process.stdout.write(`Create OK: ${baseDir}\n`);
+      return 0;
+    }
+
+    let opts: CreateOptions;
+    if (!partial.yes && isInteractiveTty()) {
+      const collected = collectInteractiveOptions(partial, input.dir ?? ".");
+      opts = collected.opts;
+      return runCreateApply(collected.baseDir, opts, partial.dryRun ?? false);
+    }
+
+    if (!partial.yes && !isInteractiveTty()) {
+      throw new Error("Refusing to proceed without --yes (stdin is not a TTY).");
+    }
+    if (!partial.key) {
+      throw new Error("--key is required in non-interactive mode.");
+    }
+    opts = resolveCreateOptions(partial, baseDir);
+    return runCreateApply(baseDir, opts, partial.dryRun ?? false);
+  } catch (err) {
+    process.stderr.write(`${err instanceof Error ? err.message : String(err)}\n`);
+    return 1;
+  }
+}
+
+async function runCreateApply(
+  baseDir: string,
+  opts: CreateOptions,
+  dryRun: boolean,
+): Promise<number> {
+  if (dryRun) {
+    const written = applyCreate(baseDir, { ...opts, dryRun: true, check: false });
+    process.stdout.write(`Would write ${written.length} file(s) under ${baseDir}\n`);
+    for (const w of written) process.stdout.write(`  ${relative(baseDir, w) || w}\n`);
+    printPostCreatePlan();
+    return 0;
+  }
+
+  mkdirSync(baseDir, { recursive: true });
+  const written = applyCreate(baseDir, {
+    ...opts,
+    dryRun: false,
+    check: false,
+    force: opts.force,
+  });
+  process.stdout.write(`Created ${written.length} file(s) under ${baseDir}\n`);
+  for (const w of written) {
+    process.stdout.write(`  ${relative(baseDir, w) || w}\n`);
+  }
+
+  await runPostCreate(baseDir, false);
+  process.stdout.write("Done.\n");
+  return 0;
+}
+
+/** Parse argv and run create (for tests and direct script invocation). */
+export async function runCreateCommand(rest: string[]): Promise<number> {
+  const { dir, opts } = parseCreateArgv(rest);
+  return runCreate({ ...opts, dir });
+}

package/src/cli.ts

@@ -20,7 +20,6 @@ import { type AnyAppConfigSnapshot, createAppConfigSnapshot } from "./config/con
 import { effectiveJsonSchema } from "./config/schema.ts";
 import { CliContext } from "./context.ts";
 import { cliHelpRender } from "./help.ts";
-import { maybeBootstrapInstallArgv } from "./install/bootstrap.ts";
 import { bootstrapMcpEnv } from "./mcp/env.ts";
 import { mcpServeStdioLoop } from "./mcp/server.ts";
 import { ParseKind, type ParseResult, parse, postParseValidate } from "./parse.ts";
@@ -95,7 +94,6 @@ export class Cli {
   }
 
   async run(argv: string[] = process.argv.slice(2)): Promise<never> {
-    argv = maybeBootstrapInstallArgv(argv, this.program);
     assertBuiltinAllowed(argv, this.caps);
 
     const prep = this.prepareDispatch(argv);

package/src/config/bootstrap.ts

@@ -4,6 +4,7 @@ settings are present before the CLI or MCP server handles a request.
 */
 
 import { readSync } from "node:fs";
+import { readPromptLine as readStdinLine } from "../prompt.ts";
 import type { CliAppConfigEntry, CliProgram } from "../types.ts";
 import {
   configEntryRequired,
@@ -124,9 +125,7 @@ function readPromptLine(mask: boolean): string {
   if (mask) {
     return readSensitiveLine();
   }
-  const buf = Buffer.alloc(4096);
-  const n = readSync(0, buf, { length: 4096 });
-  return buf.toString("utf8", 0, n).replace(/\r?\n$/, "");
+  return readStdinLine();
 }
 
 /** Whether this setting already has a non-empty value in the user's shell environment. */
@@ -149,7 +148,7 @@ function promptConfigKey(
   configure: boolean,
   jsonSchemaRequired: Set<string> | undefined,
   hostEnv: Record<string, string | undefined>,
-): { value: unknown } {
+): { value: unknown; userTyped: boolean } {
   const baseTitle = entry.title ?? defaultConfigEntryTitle(key);
   const titleWithEnv = entry.env ? `${baseTitle} (${entry.env})` : baseTitle;
   const required = configEntryRequired(key, entry, jsonSchemaRequired);
@@ -169,12 +168,12 @@ function promptConfigKey(
   }
   const input = readPromptLine(sensitive);
   if (input.length === 0 && hasCurrent) {
-    return { value: current };
+    return { value: current, userTyped: false };
   }
   if (input.length > 0) {
-    return { value: input };
+    return { value: input, userTyped: true };
   }
-  return { value: undefined };
+  return { value: undefined, userTyped: false };
 }
 
 /** Options for the interactive `install --configure` wizard. */
@@ -218,7 +217,7 @@ function promptMissingRequired(program: CliProgram): Record<string, unknown> {
       writeConfigureSetupHeading();
       headingWritten = true;
     }
-    const { value } = promptConfigKey(key, entry, undefined, false, fromSchema, hostEnv);
+    const { value, userTyped } = promptConfigKey(key, entry, undefined, false, fromSchema, hostEnv);
     if (value !== undefined && String(value).length > 0) {
       updates[key] = value;
     }
@@ -261,8 +260,16 @@ export function runInstallConfigure(
   for (const [key, entry] of Object.entries(program.appConfig.entries)) {
     const before = next[key];
     const current = resolved[key];
-    const { value } = promptConfigKey(key, entry, current, true, fromSchema, hostEnv);
+    const { value, userTyped } = promptConfigKey(key, entry, current, true, fromSchema, hostEnv);
     if (value !== undefined && String(value).length > 0) {
+      const storedInFile =
+        key in existing &&
+        existing[key] !== undefined &&
+        existing[key] !== null &&
+        String(existing[key]).length > 0;
+      if (!userTyped && !storedInFile) {
+        continue;
+      }
       if (JSON.stringify(value) !== JSON.stringify(before)) {
         changed = true;
       }

package/src/config/resolve.test.ts

@@ -109,4 +109,171 @@ describe("config/resolve", () => {
       else process.env.API_TOKEN = prev;
     }
   });
+
+  test("resolve callback supplies value when env and file are absent", () => {
+    const resolveProgram: CliProgram = {
+      ...program,
+      appConfig: {
+        ...program.appConfig!,
+        entries: {
+          ...program.appConfig!.entries,
+          apiToken: {
+            description: "Token.",
+            env: "API_TOKEN",
+            resolve: () => "from-resolve",
+          },
+        },
+      },
+    };
+    const prev = process.env.API_TOKEN;
+    delete process.env.API_TOKEN;
+    try {
+      const resolved = resolveAppConfig(resolveProgram, {});
+      expect(resolved.apiToken).toBe("from-resolve");
+    } finally {
+      if (prev !== undefined) process.env.API_TOKEN = prev;
+    }
+  });
+
+  test("env overrides resolve callback", () => {
+    const resolveProgram: CliProgram = {
+      ...program,
+      appConfig: {
+        ...program.appConfig!,
+        entries: {
+          ...program.appConfig!.entries,
+          apiToken: {
+            description: "Token.",
+            env: "API_TOKEN",
+            resolve: () => "from-resolve",
+          },
+        },
+      },
+    };
+    const prev = process.env.API_TOKEN;
+    process.env.API_TOKEN = "from-env";
+    try {
+      const resolved = resolveAppConfig(resolveProgram, {});
+      expect(resolved.apiToken).toBe("from-env");
+    } finally {
+      if (prev === undefined) delete process.env.API_TOKEN;
+      else process.env.API_TOKEN = prev;
+    }
+  });
+
+  test("file overrides resolve callback", () => {
+    const resolveProgram: CliProgram = {
+      ...program,
+      appConfig: {
+        ...program.appConfig!,
+        entries: {
+          ...program.appConfig!.entries,
+          apiToken: {
+            description: "Token.",
+            env: "API_TOKEN",
+            resolve: () => "from-resolve",
+          },
+        },
+      },
+    };
+    const prev = process.env.API_TOKEN;
+    delete process.env.API_TOKEN;
+    try {
+      const resolved = resolveAppConfig(resolveProgram, { apiToken: "from-file" });
+      expect(resolved.apiToken).toBe("from-file");
+    } finally {
+      if (prev !== undefined) process.env.API_TOKEN = prev;
+    }
+  });
+
+  test("falls back to env when resolve returns undefined", () => {
+    const resolveProgram: CliProgram = {
+      ...program,
+      appConfig: {
+        ...program.appConfig!,
+        entries: {
+          ...program.appConfig!.entries,
+          apiToken: {
+            description: "Token.",
+            env: "API_TOKEN",
+            resolve: () => undefined,
+          },
+        },
+      },
+    };
+    const hostEnv = { API_TOKEN: "from-env-fallback" };
+    const prev = process.env.API_TOKEN;
+    delete process.env.API_TOKEN;
+    try {
+      const resolved = resolveAppConfig(resolveProgram, {}, hostEnv);
+      expect(resolved.apiToken).toBe("from-env-fallback");
+    } finally {
+      if (prev !== undefined) process.env.API_TOKEN = prev;
+    }
+  });
+
+  test("resolve callback is skipped when env is set", () => {
+    let resolveCalled = false;
+    const resolveProgram: CliProgram = {
+      ...program,
+      appConfig: {
+        ...program.appConfig!,
+        entries: {
+          ...program.appConfig!.entries,
+          apiToken: {
+            description: "Token.",
+            env: "API_TOKEN",
+            resolve: () => {
+              resolveCalled = true;
+              return "from-resolve";
+            },
+          },
+        },
+      },
+    };
+    const prev = process.env.API_TOKEN;
+    process.env.API_TOKEN = "from-env";
+    try {
+      const resolved = resolveAppConfig(resolveProgram, {});
+      expect(resolved.apiToken).toBe("from-env");
+      expect(resolveCalled).toBe(false);
+    } finally {
+      if (prev === undefined) delete process.env.API_TOKEN;
+      else process.env.API_TOKEN = prev;
+    }
+  });
+
+  test("async resolve is ignored with stderr warning", () => {
+    const resolveProgram: CliProgram = {
+      ...program,
+      appConfig: {
+        ...program.appConfig!,
+        entries: {
+          ...program.appConfig!.entries,
+          apiToken: {
+            description: "Token.",
+            env: "API_TOKEN",
+            resolve: async () => "from-async-resolve",
+          },
+        },
+      },
+    };
+    const prev = process.env.API_TOKEN;
+    delete process.env.API_TOKEN;
+    const prevStderr = process.stderr.write;
+    const stderrLines: string[] = [];
+    process.stderr.write = ((chunk: string | Uint8Array) => {
+      stderrLines.push(typeof chunk === "string" ? chunk : new TextDecoder().decode(chunk));
+      return true;
+    }) as typeof process.stderr.write;
+    try {
+      const resolved = resolveAppConfig(resolveProgram, {}, { API_TOKEN: undefined });
+      expect(resolved.apiToken).toBeUndefined();
+      expect(stderrLines.join("")).toContain("returned a Promise");
+    } finally {
+      process.stderr.write = prevStderr;
+      if (prev === undefined) delete process.env.API_TOKEN;
+      else process.env.API_TOKEN = prev;
+    }
+  });
 });

package/src/config/resolve.ts

@@ -2,7 +2,7 @@
 Resolve program.appConfig values: defaults, file, env override, export to process.env.
 */
 
-import type { CliAppConfigEntry, CliProgram } from "../types.ts";
+import type { CliAppConfigEntry, CliAppConfigResolveContext, CliProgram } from "../types.ts";
 import { configEntryRequired, jsonSchemaRequiredKeys } from "./entry.ts";
 import type { AppConfigFileData } from "./file.ts";
 import { displayAppConfigPath } from "./file.ts";
@@ -93,6 +93,38 @@ export function resolveAppConfig(
   return out;
 }
 
+function tryEnvOverride(
+  program: CliProgram,
+  key: string,
+  entry: CliAppConfigEntry,
+  hostEnv?: Record<string, string | undefined>,
+): unknown {
+  if (!entry.env) {
+    return undefined;
+  }
+  const fromEnv = envOverrideValue(entry.env, hostEnv);
+  if (fromEnv === undefined) {
+    return undefined;
+  }
+  return coerceEnvValue(program, key, fromEnv);
+}
+
+function buildResolveContext(
+  program: CliProgram,
+  key: string,
+  entry: CliAppConfigEntry,
+  fileData: AppConfigFileData,
+  hostEnv?: Record<string, string | undefined>,
+): CliAppConfigResolveContext {
+  return {
+    key,
+    entry,
+    program,
+    fileValue: fileData[key],
+    envValue: entry.env ? envOverrideValue(entry.env, hostEnv) : undefined,
+  };
+}
+
 function resolveConfigKey(
   program: CliProgram,
   key: string,
@@ -100,15 +132,27 @@ function resolveConfigKey(
   fileData: AppConfigFileData,
   hostEnv?: Record<string, string | undefined>,
 ): unknown {
-  if (entry.env) {
-    const fromEnv = envOverrideValue(entry.env, hostEnv);
-    if (fromEnv !== undefined) {
-      return coerceEnvValue(program, key, fromEnv);
-    }
+  const fromEnv = tryEnvOverride(program, key, entry, hostEnv);
+  if (fromEnv !== undefined) {
+    return fromEnv;
   }
   if (key in fileData && isPresent(fileData[key])) {
     return fileData[key];
   }
+  if (entry.resolve) {
+    const fromResolve = entry.resolve(buildResolveContext(program, key, entry, fileData, hostEnv));
+    if (fromResolve != null && typeof (fromResolve as Promise<unknown>).then === "function") {
+      process.stderr.write(
+        `[argsbarg] config "${key}": resolve() returned a Promise; use a synchronous resolver (e.g. Bun.spawnSync with piped stdout).\n`,
+      );
+    } else if (isPresent(fromResolve)) {
+      return fromResolve;
+    }
+  }
+  const fromEnvFallback = tryEnvOverride(program, key, entry, hostEnv);
+  if (fromEnvFallback !== undefined) {
+    return fromEnvFallback;
+  }
   const def = schemaDefaultForKey(program, key);
   if (def !== undefined) {
     return def;

package/src/docs/api-guide.test.ts

@@ -71,21 +71,20 @@ test("generateApiGuide resolves program key in install notes", () => {
   };
   const md = generateApiGuide(fixture);
   expect(md).not.toContain("{argsbarg:program}");
-  expect(md).toContain("myapp install --yes");
+  expect(md).toContain("brew install");
   expect(md).not.toContain("Upgrade to latest release");
 });
 
-test("generateApiGuide includes upgrade section when updateGetLatest is set", () => {
+test("generateApiGuide mentions Homebrew upgrade", () => {
   const fixture: CliProgram = {
     key: "myapp",
     version: "1.0.0",
     description: "Demo app.",
-    install: { updateGetLatest: async () => ({ path: process.execPath }) },
     commands: [{ key: "run", description: "Run.", handler: () => {} }],
   };
   const md = generateApiGuide(fixture);
-  expect(md).toContain("Upgrade to latest release");
-  expect(md).toContain("myapp install --update");
+  expect(md).toContain("brew upgrade");
+  expect(md).not.toContain("install --update");
 });
 
 test("generateApiGuide resolves {argsbarg:program} in consumer notes", () => {

package/src/docs/docs.test.ts

@@ -217,7 +217,8 @@ test("generateMcpGuide includes schema URI and install targets", () => {
   expect(guide).toContain("claude_desktop_config.json");
   expect(guide).toContain("## Installation");
   expect(guide).toContain("## Running directly");
-  expect(guide).toContain("install --app");
+  expect(guide).toContain("install --mcp");
+  expect(guide).toContain("brew install myapp");
   expect(guide).toContain("OpenAI Codex");
   expect(guide).toContain("ChatGPT");
 });

package/src/docs/mcp-guide.ts

@@ -111,7 +111,7 @@ export function generateMcpGuide(root: CliProgram): string {
 
   if (caps.install) {
     lines.push(
-      `Install the CLI first so \`${root.key}\` is on your PATH (e.g. \`${root.key} install --app --yes\` or \`install --all --yes\`). Host configs reference the app by name.`,
+      `Install the CLI first so \`${root.key}\` is on your PATH (e.g. \`brew install ${root.key}\`). Host configs reference the app by name.`,
       "",
     );
   } else {
@@ -167,13 +167,12 @@ export function generateMcpGuide(root: CliProgram): string {
     "",
   );
 
-  if (mcp.shellEnv) {
-    lines.push("## Environment", "");
-    lines.push(
-      "- **`shellEnv`** — captures login-shell environment at MCP startup (PATH, toolchain shims, exports).",
-    );
-    lines.push("");
-  }
+  lines.push(
+    "## Environment",
+    "",
+    "- **`shellEnv`** — on by default; captures login-shell environment at MCP startup (PATH, toolchain shims, exports). Opt out with `shellEnv: false`.",
+    "",
+  );
 
   if (root.appConfig?.entries && Object.keys(root.appConfig.entries).length > 0) {
     lines.push("## Configuration", "");

package/src/index.ts

@@ -9,6 +9,7 @@ module layout.
 
 export { Cli, type CliInvokeKind, type CliInvokeResult } from "./cli.ts";
 export { cliErrWithHelp } from "./cli-errors.ts";
+export { displayAppConfigPath, resolveAppConfigPath } from "./config/file.ts";
 export type { CliLeafInputs } from "./context.ts";
 export { CliContext } from "./context.ts";
 export {
@@ -26,19 +27,13 @@ export {
   shouldRunHeadlessWithYes,
   wantsExplicitJson,
 } from "./headless.ts";
-export type { GhReleaseUpdateConfig, GhVersionCheckConfig } from "./install/gh-release-update.ts";
-export {
-  createGhFetchLatest,
-  createGhVersionCheck,
-  ghReleaseUpdateGetLatest,
-  isAlreadyCurrent,
-  parseReleaseTag,
-} from "./install/gh-release-update.ts";
 export type { McpBundlePaths, PackMcpBundleOpts } from "./mcp/bundle.ts";
 export { defaultMcpBundlePaths, generateMcpManifest, packMcpBundle } from "./mcp/bundle.ts";
 export type {
   CliAppConfig,
   CliAppConfigEntry,
+  CliAppConfigResolveContext,
+  CliAppConfigResolveFn,
   CliDocsConfig,
   CliDocsTopic,
   CliHandler,
@@ -52,8 +47,6 @@ export type {
   CliOption,
   CliPositional,
   CliProgram,
-  CliUpdateArtifact,
-  CliUpdateGetLatest,
   InstallAgentIntegration,
   InstallTargetSpec,
   ResolvedInstallTarget,

package/src/install/binary-placement.test.ts

@@ -0,0 +1,101 @@
+import { afterEach, beforeEach, describe, expect, test } from "bun:test";
+import { chmodSync, mkdirSync, mkdtempSync, rmSync, symlinkSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import type { CliProgram } from "../types.ts";
+import {
+  isAppInstalled,
+  isExternallyManagedBinary,
+  resolvePathCommand,
+} from "./binary-placement.ts";
+
+const program: CliProgram = {
+  key: "placementapp",
+  version: "1.0.0",
+  description: "x",
+  handler: () => {},
+};
+
+let tmp: string;
+let prevPath: string | undefined;
+
+beforeEach(() => {
+  tmp = mkdtempSync(join(tmpdir(), "argsbarg-placement-"));
+  prevPath = process.env.PATH;
+});
+
+afterEach(() => {
+  if (prevPath === undefined) delete process.env.PATH;
+  else process.env.PATH = prevPath;
+  rmSync(tmp, { recursive: true, force: true });
+});
+
+describe("isExternallyManagedBinary", () => {
+  test("false when command is not on PATH", () => {
+    process.env.PATH = tmp;
+    expect(isExternallyManagedBinary("placementapp-not-on-path")).toBe(false);
+  });
+
+  test("true when PATH resolves to execPath", () => {
+    const bin = join(tmp, "placementapp");
+    writeFileSync(bin, "#!/bin/sh\n", "utf8");
+    chmodSync(bin, 0o755);
+    process.env.PATH = tmp;
+    expect(isExternallyManagedBinary("placementapp", bin)).toBe(true);
+  });
+
+  test("true when PATH entry is a symlink to execPath", () => {
+    const bin = join(tmp, "placementapp");
+    const target = join(tmp, "real-binary");
+    writeFileSync(target, "fake", "utf8");
+    symlinkSync(target, bin);
+    process.env.PATH = tmp;
+    expect(isExternallyManagedBinary("placementapp", target)).toBe(true);
+  });
+
+  test("false when PATH points at a different binary", () => {
+    const bin = join(tmp, "placementapp");
+    const other = join(tmp, "other");
+    writeFileSync(bin, "a", "utf8");
+    writeFileSync(other, "b", "utf8");
+    process.env.PATH = tmp;
+    expect(isExternallyManagedBinary("placementapp", other)).toBe(false);
+  });
+});
+
+describe("isAppInstalled", () => {
+  test("true when externally managed", () => {
+    const bin = join(tmp, program.key);
+    const prevExec = process.execPath;
+    writeFileSync(bin, "x", "utf8");
+    chmodSync(bin, 0o755);
+    process.env.PATH = tmp;
+    process.execPath = bin;
+    try {
+      expect(isAppInstalled(program)).toBe(true);
+    } finally {
+      process.execPath = prevExec;
+    }
+  });
+
+  test("false when not on PATH and no local copy", () => {
+    const home = mkdtempSync(join(tmpdir(), "argsbarg-placement-home-"));
+    const prevHome = process.env.HOME;
+    process.env.HOME = home;
+    process.env.PATH = tmp;
+    try {
+      expect(isAppInstalled(program)).toBe(false);
+    } finally {
+      if (prevHome === undefined) delete process.env.HOME;
+      else process.env.HOME = prevHome;
+      rmSync(home, { recursive: true, force: true });
+    }
+  });
+});
+
+describe("resolvePathCommand", () => {
+  test("returns undefined when missing", () => {
+    process.env.PATH = tmp;
+    expect(resolvePathCommand("missing-cmd")).toBeUndefined();
+  });
+});