@akasecurity/ai-tc-claude-code 0.9.6 → 0.9.7

package/scripts/dashboard.js

@@ -1,5 +1,112 @@
 // src/dashboard.ts
-import { spawn, spawnSync } from "child_process";
+import { spawn, spawnSync as spawnSync2 } from "child_process";
+
+// ../../packages/plugin-sdk/src/bare-command.ts
+import { spawnSync } from "child_process";
+import { homedir } from "os";
+import { win32 } from "path";
+var CMD_LINE_MAX = 8191;
+var CMD_WRAPPER_ALLOWANCE = 64;
+var DIRECT_EXTENSIONS = /* @__PURE__ */ new Set([".exe", ".com"]);
+var CMD_HAZARDS = [
+  ['"', "a double quote, which would close the quoted argument"],
+  ["%", "a percent sign, which cmd.exe expands inside quotes and re-parses"],
+  ["!", "an exclamation mark, which cmd.exe expands when delayed expansion is on"],
+  ["\r", "a carriage return, which a Windows command line cannot carry"],
+  ["\n", "a line break, which a Windows command line cannot carry"],
+  ["\0", "a NUL byte"]
+];
+var BACKSLASH = 92;
+var BARE_COMMAND_ERROR_CODE = "ERR_AKA_WINDOWS_ARGV";
+var BareCommandUnsupportedError = class extends Error {
+  code = BARE_COMMAND_ERROR_CODE;
+  reason;
+  constructor(reason) {
+    super(`cannot spawn this command on Windows: ${reason}`);
+    this.name = "BareCommandUnsupportedError";
+    this.reason = reason;
+  }
+};
+function isBareCommandUnsupported(err) {
+  return typeof err === "object" && err !== null && err.code === BARE_COMMAND_ERROR_CODE && typeof err.reason === "string";
+}
+function cmdLineHazard(command, args2) {
+  for (const [index, arg] of [command, ...args2].entries()) {
+    for (const [char, why] of CMD_HAZARDS) {
+      if (arg.includes(char)) {
+        const where = index === 0 ? "the command name" : `argument ${String(index)}`;
+        return `${where} contains ${why}`;
+      }
+    }
+  }
+  const length = quoteCommandLine(command, args2).length + CMD_WRAPPER_ALLOWANCE;
+  if (length > CMD_LINE_MAX) {
+    return `the command line is ${String(length)} characters once cmd.exe's own prefix is counted, over its ${String(CMD_LINE_MAX)}`;
+  }
+  return void 0;
+}
+function quoteForCmd(value) {
+  let runStart = value.length;
+  while (runStart > 0 && value.charCodeAt(runStart - 1) === BACKSLASH) runStart -= 1;
+  const trailingBackslashes = value.slice(runStart);
+  const body = value.slice(0, runStart);
+  return `"${body}${trailingBackslashes}${trailingBackslashes}"`;
+}
+function quoteCommandLine(command, args2) {
+  return [command, ...args2].map(quoteForCmd).join(" ");
+}
+var RESOLVE_TIMEOUT_MS = 5e3;
+function systemWhere(env) {
+  for (const [key, value] of Object.entries(env ?? process.env)) {
+    if (key.toLowerCase() !== "systemroot") continue;
+    if (typeof value !== "string" || value.trim() === "") return void 0;
+    return win32.join(value, "System32", "where.exe");
+  }
+  return void 0;
+}
+function resolveWindowsCommand(command, env, home) {
+  try {
+    const probe = spawnSync(systemWhere(env) ?? "where", [command], {
+      encoding: "utf8",
+      cwd: home,
+      windowsHide: true,
+      timeout: RESOLVE_TIMEOUT_MS,
+      ...env === void 0 ? {} : { env }
+    });
+    if (probe.status !== 0 || typeof probe.stdout !== "string") return void 0;
+    const first = probe.stdout.split(/\r?\n/).find((line) => line.trim() !== "");
+    return first?.trim();
+  } catch {
+    return void 0;
+  }
+}
+function isDirectlyExecutable(file) {
+  return DIRECT_EXTENSIONS.has(win32.extname(file).toLowerCase());
+}
+function planBareCommand(command, args2, deps = {}) {
+  const platform = deps.platform ?? process.platform;
+  if (platform !== "win32") {
+    return { file: command, args: args2, options: {}, viaShell: false, resolved: void 0 };
+  }
+  const home = deps.home ?? homedir();
+  const resolve = deps.resolve ?? resolveWindowsCommand;
+  const resolved = resolve(command, deps.env, home);
+  if (resolved !== void 0 && isDirectlyExecutable(resolved)) {
+    return { file: resolved, args: args2, options: { cwd: home }, viaShell: false, resolved };
+  }
+  const hazard = cmdLineHazard(command, args2);
+  if (hazard !== void 0) {
+    const why = resolved === void 0 ? `${command} did not resolve to an executable, so it could only be run through cmd.exe` : `${command} resolves only to a batch shim, which must be run through cmd.exe`;
+    throw new BareCommandUnsupportedError(`${why}, and ${hazard}`);
+  }
+  return {
+    file: quoteCommandLine(command, args2),
+    args: [],
+    options: { shell: true, cwd: home },
+    viaShell: true,
+    resolved
+  };
+}
 
 // src/dashboard-launch.ts
 var DEFAULT_PORT = "4319";
@@ -20,27 +127,41 @@ function startMessage(url) {
 It serves your local store at ~/.aka/data; leave it running (stop it with Ctrl-C in that process).`;
 }
 var INSTALL_HINT = "The AKA dashboard is launched by the `aka` CLI, which the plugin does not bundle.\nInstall it and run /aka:dashboard again:\n  npm i -g @akasecurity/cli      # then it is on your PATH as `aka`\nFrom a repo checkout instead:  pnpm --filter @akasecurity/cli dev dashboard";
+function unsupportedArgvMessage(reason) {
+  return `The AKA dashboard could not be launched: ${reason}.
+Re-run without that flag, or start the dashboard directly:
+  aka dashboard`;
+}
+var PROBE_FLAG = "--help";
+function akaMissing(plan, probe) {
+  if (plan.viaShell) return plan.resolved === void 0;
+  const { error } = probe(plan.file, [PROBE_FLAG], { stdio: "ignore", ...plan.options });
+  return error?.code === "ENOENT";
+}
 
 // src/dashboard.ts
 var args = process.argv.slice(2);
-function akaMissing() {
-  const probe = spawnSync("aka", ["--help"], { stdio: "ignore" });
-  return probe.error !== void 0 && probe.error.code === "ENOENT";
-}
 try {
-  if (akaMissing()) {
+  const plan = planBareCommand("aka", ["dashboard", ...args]);
+  if (akaMissing(plan, (file, probeArgs, options) => spawnSync2(file, [...probeArgs], options))) {
     process.stdout.write(`${INSTALL_HINT}
 `);
     process.exit(0);
   }
-  const child = spawn("aka", ["dashboard", ...args], { detached: true, stdio: "ignore" });
+  const child = spawn(plan.file, [...plan.args], {
+    detached: true,
+    stdio: "ignore",
+    ...plan.options
+  });
   child.on("error", () => {
   });
   child.unref();
   process.stdout.write(`${startMessage(dashboardUrl(parsePort(args)))}
 `);
-} catch {
-  process.stdout.write(`${INSTALL_HINT}
-`);
+} catch (err) {
+  process.stdout.write(
+    `${isBareCommandUnsupported(err) ? unsupportedArgvMessage(err.reason) : INSTALL_HINT}
+`
+  );
   process.exit(0);
 }