@dreamboard-games/cli 0.1.30-alpha.18 → 0.1.30-alpha.19

package/dist/{global-config-VQWFTIAV.js → global-config-UHGWFJIK.js}

@@ -4,7 +4,7 @@ import {
   getGlobalConfigPath,
   loadGlobalConfig,
   saveGlobalConfig
-} from "./chunk-J3CWZHY7.js";
+} from "./chunk-VWMKJL4A.js";
 import "./chunk-FFO2IJL3.js";
 import "./chunk-2H7UOFLK.js";
 export {
@@ -13,4 +13,4 @@ export {
   loadGlobalConfig,
   saveGlobalConfig
 };
-//# sourceMappingURL=global-config-VQWFTIAV.js.map
+//# sourceMappingURL=global-config-UHGWFJIK.js.map

package/dist/index.js

@@ -48,6 +48,7 @@ import {
   parseQueryCommandArgs,
   parseStatusCommandArgs,
   parseSyncCommandArgs,
+  presentCliError,
   projectIdFromSessionGameSource,
   queueProjectRevisionCompileSdk,
   refreshResolvedAuthSession,
@@ -64,7 +65,7 @@ import {
   toDreamboardApiError,
   valueOrUndefined,
   waitForCompiledResultJobSdk
-} from "./chunk-2WB3DYW4.js";
+} from "./chunk-R6RB4EKH.js";
 import {
   applyWorkspaceCodegen,
   assertCliStaticScaffoldComplete,
@@ -116,7 +117,7 @@ import {
   writeSnapshotFromFiles,
   writeSourceFiles,
   writeWorkspaceTextFile
-} from "./chunk-2XMBZPL5.js";
+} from "./chunk-YRSE5DLH.js";
 import {
   clearCredentials,
   getActiveCredentialBackendName,
@@ -127,7 +128,7 @@ import {
   saveGlobalConfig,
   setAccessOnlySession,
   setCredentials
-} from "./chunk-J3CWZHY7.js";
+} from "./chunk-VWMKJL4A.js";
 import {
   DEFAULT_LOGIN_TIMEOUT_MS,
   MANIFEST_FILE,
@@ -1874,6 +1875,164 @@ function openBrowser(url) {
   child.unref();
 }
 
+// ../../packages/cli-core/src/results/command-result.ts
+var COMMAND_RESULT_SCHEMA_VERSION = 1;
+var ExitCode = /* @__PURE__ */ ((ExitCode2) => {
+  ExitCode2[ExitCode2["Ok"] = 0] = "Ok";
+  ExitCode2[ExitCode2["Unexpected"] = 1] = "Unexpected";
+  ExitCode2[ExitCode2["Unauthenticated"] = 2] = "Unauthenticated";
+  ExitCode2[ExitCode2["Forbidden"] = 3] = "Forbidden";
+  ExitCode2[ExitCode2["Conflict"] = 4] = "Conflict";
+  ExitCode2[ExitCode2["Validation"] = 5] = "Validation";
+  ExitCode2[ExitCode2["Transient"] = 6] = "Transient";
+  ExitCode2[ExitCode2["CommitNotPushed"] = 7] = "CommitNotPushed";
+  ExitCode2[ExitCode2["ConfirmationRequired"] = 8] = "ConfirmationRequired";
+  return ExitCode2;
+})(ExitCode || {});
+function commandSuccess(command, result, nextActions = []) {
+  return {
+    schemaVersion: COMMAND_RESULT_SCHEMA_VERSION,
+    ok: true,
+    command,
+    result,
+    nextActions
+  };
+}
+function commandFailure(command, problem, exitCode, nextActions = []) {
+  return {
+    schemaVersion: COMMAND_RESULT_SCHEMA_VERSION,
+    ok: false,
+    command,
+    problem,
+    nextActions,
+    exitCode
+  };
+}
+
+// ../../packages/cli-core/src/progress/progress-events.ts
+var PROGRESS_EVENT_SCHEMA_VERSION = 1;
+function createProgressSequencer(input) {
+  let seq = 0;
+  const sequencer = {
+    next(event) {
+      seq += 1;
+      return {
+        schemaVersion: PROGRESS_EVENT_SCHEMA_VERSION,
+        runId: input.runId,
+        seq,
+        ...event
+      };
+    },
+    terminal(result) {
+      seq += 1;
+      return {
+        schemaVersion: PROGRESS_EVENT_SCHEMA_VERSION,
+        runId: input.runId,
+        seq,
+        command: input.command,
+        kind: "result",
+        event: "terminal",
+        payload: result
+      };
+    }
+  };
+  return sequencer;
+}
+
+// ../../packages/cli-core/src/auth/git-credential.ts
+var DEFAULT_REPOSITORY_PATH = /^repos\/[0-9a-fA-F-]{36}\.git$/;
+function parseGitCredentialRequest(input) {
+  const result = {};
+  for (const line of input.split(/\r?\n/)) {
+    if (line === "") continue;
+    const separator = line.indexOf("=");
+    if (separator <= 0) continue;
+    result[line.slice(0, separator)] = line.slice(separator + 1);
+  }
+  return {
+    protocol: result.protocol,
+    host: result.host,
+    path: result.path
+  };
+}
+function formatGitCredentialResponse(response) {
+  return `username=${response.username}
+password=${response.password}
+
+`;
+}
+async function resolveGitCredential(input) {
+  const protocol = input.request.protocol?.toLowerCase();
+  const host = input.request.host?.toLowerCase();
+  const path12 = normalizeCredentialPath(input.request.path);
+  const allowedHosts = new Set(
+    input.policy.allowedHosts.map((value) => value.toLowerCase())
+  );
+  const pathPattern = input.policy.allowedPathPattern ?? DEFAULT_REPOSITORY_PATH;
+  if (protocol !== "https" || !host || !allowedHosts.has(host)) {
+    return null;
+  }
+  if (!path12 || !pathPattern.test(path12)) {
+    return null;
+  }
+  const token = await input.tokenManager.resolveGitToken();
+  return {
+    username: "x-dreamboard-token",
+    password: token.token
+  };
+}
+function normalizeCredentialPath(value) {
+  if (!value) return null;
+  return value.replace(/^\/+/, "");
+}
+
+// ../../packages/cli-core/src/git/system-git.ts
+import { execFile } from "child_process";
+import { promisify } from "util";
+var execFileAsync = promisify(execFile);
+
+// src/services/git/git-credential-helper.ts
+var DEFAULT_ALLOWED_GIT_HOSTS = [
+  "git.staging.dreamboard.games",
+  "git.dreamboard.games"
+];
+async function runGitCredentialHelper(input = {}) {
+  const stdin = input.stdin ?? process.stdin;
+  const stdout = input.stdout ?? process.stdout;
+  const env2 = input.env ?? process.env;
+  const request = parseGitCredentialRequest(await readAll(stdin));
+  const response = await resolveGitCredential({
+    request,
+    policy: {
+      allowedHosts: resolveAllowedGitHosts(env2)
+    },
+    tokenManager: createUserTokenManager(
+      resolveConfig(
+        await loadGlobalConfig(),
+        {},
+        void 0,
+        await getStoredSession()
+      )
+    )
+  });
+  if (!response) {
+    return;
+  }
+  stdout.write(formatGitCredentialResponse(response));
+}
+function resolveAllowedGitHosts(env2) {
+  const configured = env2.DREAMBOARD_GIT_ALLOWED_HOSTS?.split(",").map((host) => host.trim()).filter(Boolean);
+  return configured && configured.length > 0 ? configured : DEFAULT_ALLOWED_GIT_HOSTS;
+}
+async function readAll(stream) {
+  let data = "";
+  stream.setEncoding("utf8");
+  for await (const chunk of stream) {
+    data += chunk;
+  }
+  return data;
+}
+
 // src/commands/auth.ts
 async function loginWithBrowser(config, quiet) {
   const state = crypto2.randomUUID();
@@ -1928,7 +2087,7 @@ var auth_default = defineCommand({
   args: {
     action: {
       type: "positional",
-      description: IS_PUBLISHED_BUILD ? "Action: clear | login" : "Action: set | clear | login | env | status",
+      description: IS_PUBLISHED_BUILD ? "Action: clear | login" : "Action: set | clear | login | env | status | git-credential",
       required: true
     },
     ...IS_PUBLISHED_BUILD ? {} : {
@@ -1955,6 +2114,10 @@ var auth_default = defineCommand({
     const parsedArgs = parseAuthCommandArgs(args);
     const action = parsedArgs.action;
     const globalConfig = await loadGlobalConfig();
+    if (action === "git-credential") {
+      await runGitCredentialHelper();
+      return;
+    }
     if (IS_PUBLISHED_BUILD && action !== "login" && action !== "clear") {
       throw new Error(
         "The published Dreamboard CLI only supports browser login and logout. Use `dreamboard login` or `dreamboard logout`."
@@ -1995,7 +2158,7 @@ var auth_default = defineCommand({
       return;
     }
     if (action === "clear") {
-      await clearCredentials();
+      await clearCredentials("auth_clear_command");
       consola.success(
         `Stored Dreamboard session cleared from ${getGlobalAuthPath()}.`
       );
@@ -5997,7 +6160,7 @@ var logout_default = defineCommand({
   meta: { name: "logout", description: "Clear the stored Dreamboard session" },
   args: {},
   async run() {
-    await clearCredentials();
+    await clearCredentials("logout_command");
     consola.success(`Logged out. Cleared session from ${getGlobalAuthPath()}.`);
   }
 });
@@ -6976,8 +7139,225 @@ var test_default = defineCommand({
   }
 });
 
+// src/machine-output.ts
+import crypto4 from "crypto";
+function consumeMachineOutputMode(argv2) {
+  let mode = null;
+  for (let index = argv2.length - 1; index >= 2; index -= 1) {
+    const arg = argv2[index];
+    if (arg !== "--json" && arg !== "--json-events") continue;
+    const nextMode = arg === "--json" ? "json" : "json-events";
+    if (mode && mode !== nextMode) {
+      throw new Error("Use only one machine output mode: --json or --json-events.");
+    }
+    mode = nextMode;
+    argv2.splice(index, 1);
+  }
+  return mode ? {
+    mode,
+    runId: crypto4.randomUUID()
+  } : null;
+}
+function commandPathToId(path12) {
+  const [first, second] = path12;
+  if (first === "auth") {
+    if (second === "git-credential") return "auth.git_credential";
+    if (second === "status") return "auth.status";
+    if (second === "clear") return "auth.logout";
+    return "auth.login";
+  }
+  switch (first) {
+    case "login":
+      return "auth.login";
+    case "logout":
+      return "auth.logout";
+    case "new":
+      return "project.create";
+    case "clone":
+      return "project.clone";
+    case "status":
+    case "pull":
+      return "project.status";
+    case "sync":
+      return "verify";
+    case "compile":
+      return "build";
+    case "test":
+      return "test";
+    case "dev":
+    case "join":
+      return "dev";
+    case "config":
+    case "query":
+      return "doctor";
+    default:
+      return "doctor";
+  }
+}
+async function runWithMachineOutput(context, command, run) {
+  const sequencer = createProgressSequencer({
+    runId: context.runId,
+    command
+  });
+  if (context.mode === "json-events") {
+    writeJsonLine(
+      sequencer.next({
+        command,
+        kind: "progress",
+        event: "started"
+      })
+    );
+  }
+  const previousExitCode = process.exitCode;
+  process.exitCode = 0;
+  try {
+    const captured = await captureProcessWrites(async () => {
+      await run();
+    });
+    const exitCode = typeof process.exitCode === "number" ? process.exitCode : 0 /* Ok */;
+    const result = exitCode === 0 ? commandSuccess(command, captured) : commandFailure(
+      command,
+      {
+        title: "Command failed",
+        detail: `Command completed with exit code ${exitCode}.`,
+        code: "COMMAND_EXIT_CODE"
+      },
+      normalizeExitCode(exitCode)
+    );
+    emitMachineResult(context, sequencer.terminal(result), result);
+    process.exitCode = exitCode;
+  } catch (error) {
+    const failure = commandFailure(
+      command,
+      problemFromError(error),
+      exitCodeFromError(error),
+      nextActionsFromError(error)
+    );
+    emitMachineResult(context, sequencer.terminal(failure), failure);
+    process.exit(exitCodeFromError(error));
+  } finally {
+    if (process.exitCode === 0 && previousExitCode) {
+      process.exitCode = previousExitCode;
+    }
+  }
+}
+function emitMachineFailureAndExit(context, command, error) {
+  const sequencer = createProgressSequencer({
+    runId: context.runId,
+    command
+  });
+  const failure = commandFailure(
+    command,
+    problemFromError(error),
+    exitCodeFromError(error),
+    nextActionsFromError(error)
+  );
+  emitMachineResult(context, sequencer.terminal(failure), failure);
+  process.exit(failure.exitCode);
+}
+async function captureProcessWrites(run) {
+  const stdoutWrite = process.stdout.write.bind(process.stdout);
+  const stderrWrite = process.stderr.write.bind(process.stderr);
+  let stdout = "";
+  let stderr = "";
+  process.stdout.write = ((chunk, ...args) => {
+    stdout += stringifyChunk(chunk);
+    const callback = args.find((arg) => typeof arg === "function");
+    callback?.();
+    return true;
+  });
+  process.stderr.write = ((chunk, ...args) => {
+    stderr += stringifyChunk(chunk);
+    const callback = args.find((arg) => typeof arg === "function");
+    callback?.();
+    return true;
+  });
+  try {
+    await run();
+    return {
+      exitCode: typeof process.exitCode === "number" ? process.exitCode : 0 /* Ok */,
+      stdout,
+      stderr
+    };
+  } finally {
+    process.stdout.write = stdoutWrite;
+    process.stderr.write = stderrWrite;
+  }
+}
+function emitMachineResult(context, terminalEvent, result) {
+  if (context.mode === "json-events") {
+    writeJsonLine(terminalEvent);
+    return;
+  }
+  writeJsonLine(result);
+}
+function writeJsonLine(value) {
+  process.stdout.write(`${JSON.stringify(value)}
+`);
+}
+function stringifyChunk(chunk) {
+  if (typeof chunk === "string") return chunk;
+  if (chunk instanceof Uint8Array) return Buffer.from(chunk).toString("utf8");
+  return String(chunk);
+}
+function problemFromError(error) {
+  if (isDreamboardApiError(error)) {
+    return {
+      type: error.problem.type,
+      title: error.problem.title,
+      status: error.problem.status,
+      detail: error.problem.detail,
+      code: error.problem.type
+    };
+  }
+  const presentation = presentCliError(error);
+  return {
+    title: presentation.message || "Command failed",
+    detail: presentation.resolution,
+    code: error instanceof Error ? error.name : void 0
+  };
+}
+function exitCodeFromError(error) {
+  if (isStaleContractArtifactError(error)) return 5 /* Validation */;
+  if (isDreamboardApiError(error)) {
+    if (error.status === 401) return 2 /* Unauthenticated */;
+    if (error.status === 403) return 3 /* Forbidden */;
+    if (error.status === 409) return 4 /* Conflict */;
+    if (error.status === 422 || error.status === 400) {
+      return 5 /* Validation */;
+    }
+    if (error.retryable || error.status === 429 || error.status >= 500) {
+      return 6 /* Transient */;
+    }
+  }
+  return 1 /* Unexpected */;
+}
+function normalizeExitCode(exitCode) {
+  return Object.values(ExitCode).includes(exitCode) ? exitCode : 1 /* Unexpected */;
+}
+function nextActionsFromError(error) {
+  if (isDreamboardApiError(error) && error.status === 401) {
+    return [
+      {
+        id: "auth.login",
+        environment: "staging",
+        unattended: false
+      }
+    ];
+  }
+  return [];
+}
+
 // src/cli-main.ts
+var machineOutputContext = null;
 function handleFatalError(error) {
+  if (machineOutputContext) {
+    emitMachineFailureAndExit(
+      machineOutputContext,
+      commandPathToId(process.argv.slice(2)),
+      error
+    );
+  }
   const message = formatCliError(error);
   process.stderr.write(`Error: ${message}
 `);
@@ -7001,21 +7381,31 @@ var publicSubCommands = {
   logout: logout_default,
   config: config_default
 };
-function wrapCommandMapForCli(commands, fatalErrorHandler) {
+function wrapCommandMapForCli(commands, fatalErrorHandler, parentPath = []) {
   return Object.fromEntries(
     Object.entries(commands).map(([name, command]) => [
       name,
-      wrapCommandForCli(command, fatalErrorHandler)
+      wrapCommandForCli(command, fatalErrorHandler, [...parentPath, name])
     ])
   );
 }
-function wrapCommandForCli(command, fatalErrorHandler = handleFatalError) {
+function wrapCommandForCli(command, fatalErrorHandler = handleFatalError, commandPath = []) {
   const subCommands = command.subCommands;
   return {
     ...command,
-    subCommands: subCommands ? wrapCommandMapForCli(subCommands, fatalErrorHandler) : void 0,
+    subCommands: subCommands ? wrapCommandMapForCli(subCommands, fatalErrorHandler, commandPath) : void 0,
     run: command.run ? async (context) => {
       try {
+        if (machineOutputContext) {
+          await runWithMachineOutput(
+            machineOutputContext,
+            commandPathToId(process.argv.slice(2)),
+            async () => {
+              await command.run?.(context);
+            }
+          );
+          return;
+        }
         return await command.run?.(context);
       } catch (error) {
         fatalErrorHandler(error);
@@ -7024,6 +7414,7 @@ function wrapCommandForCli(command, fatalErrorHandler = handleFatalError) {
   };
 }
 function runDreamboardCli(internalSubCommands = {}) {
+  machineOutputContext = consumeMachineOutputMode(process.argv);
   const subCommands = wrapCommandMapForCli(
     {
       ...publicSubCommands,