@cimplify/cli 0.15.2 → 0.16.0

package/dist/create-4S2EAUR3.mjs

@@ -0,0 +1,10 @@
+#!/usr/bin/env node
+export { createProject, run as default, parseTemplate } from './chunk-EAV2P4N3.mjs';
+import './chunk-CNZAOVSK.mjs';
+import './chunk-T4MW3PD4.mjs';
+import './chunk-KQNZKV6E.mjs';
+import './chunk-AKACUJ3W.mjs';
+import './chunk-25ZPFHLF.mjs';
+import './chunk-SGT5IJVW.mjs';
+import './chunk-XQAHREKO.mjs';
+import './chunk-KOD4GBQ5.mjs';

package/dist/credits-NJOAOPPW.mjs

@@ -0,0 +1,33 @@
+#!/usr/bin/env node
+import { requireInteractiveProject, buildLocal, renderDiagnostics } from './chunk-CPBESPWK.mjs';
+import './chunk-VHK7WBO3.mjs';
+import './chunk-5HP2INMY.mjs';
+import './chunk-JKECUAAV.mjs';
+import './chunk-T4MW3PD4.mjs';
+import './chunk-KQNZKV6E.mjs';
+import './chunk-ZUCDXRFI.mjs';
+import './chunk-EYEMPIMP.mjs';
+import './chunk-AKACUJ3W.mjs';
+import './chunk-25ZPFHLF.mjs';
+import './chunk-SGT5IJVW.mjs';
+import './chunk-TT4YI33G.mjs';
+import { info, dim, result } from './chunk-KOD4GBQ5.mjs';
+
+// src/interactives/commands/credits.ts
+async function run() {
+  const root = process.cwd();
+  requireInteractiveProject(root, "credits");
+  const { result: built } = await buildLocal(root);
+  const credits = built.package?.credits ?? [];
+  if (built.package === null) {
+    for (const line of renderDiagnostics(built.diagnostics)) info(line);
+  }
+  for (const credit of credits) {
+    const tags = [credit.modified ? "modified" : null, credit.ai === void 0 ? null : credit.ai === "generated" ? "made with AI" : "AI-assisted"].filter((t) => t !== null);
+    info(`${credit.title} by ${credit.authors.join(", ")} ${dim(`(${credit.licence}${tags.length > 0 ? `; ${tags.join(", ")}` : ""})`)}`);
+  }
+  if (credits.length === 0) info(dim("no credits; add [[credits]] to interactive.toml or Workshop content with cimplify add"));
+  result(credits);
+}
+
+export { run as default };

package/dist/{deploy-JE6TUYCL.mjs → deploy-26Y4UGZZ.mjs}

@@ -1,15 +1,15 @@
 #!/usr/bin/env node
-import { detectPackageManager } from './chunk-F2UI225N.mjs';
-import { fetchRepoRecord, fetchCloneToken } from './chunk-A6WHBSXZ.mjs';
-import { pollDeployment } from './chunk-NK6VC264.mjs';
-import './chunk-I2UP7YTG.mjs';
-import { promptYesNo } from './chunk-TH4XENKH.mjs';
-import { REPO_PROVIDER, ENV_SCOPE, DEPLOY_TRIGGER, DEPLOYMENT_STATUS, TOKEN_PURPOSE } from './chunk-MXYUAJEW.mjs';
-import { isFreestyleRemote, gitDetectRoot, gitStatusPorcelain, gitCurrentBranch, gitCurrentSha, gitGetRemoteUrl, gitPushToUrl, gitPush } from './chunk-KN2YSKXZ.mjs';
-import { parseArgs, flagBool, flagString } from './chunk-5KYR6WJB.mjs';
-import { ApiClient } from './chunk-NYXA6X56.mjs';
-import { readAuth, readProjectLink, writeProjectState } from './chunk-MLE4MVYC.mjs';
-import { info, dim, step, CliError, CLI_ERROR_CODE, success, result, EXIT_CODE } from './chunk-3QUK5BPY.mjs';
+import { detectPackageManager } from './chunk-LNMITJ4Z.mjs';
+import { fetchRepoRecord, fetchCloneToken } from './chunk-Q6CF4C3E.mjs';
+import { pollDeployment } from './chunk-54J3XR4T.mjs';
+import './chunk-SAXGWS2K.mjs';
+import { promptYesNo } from './chunk-I4HNHPEM.mjs';
+import { isManagedRemote, gitDetectRoot, gitStatusPorcelain, gitCurrentBranch, gitCurrentSha, gitGetRemoteUrl, gitPushToUrl, gitPush } from './chunk-EDZSOL5O.mjs';
+import { isManagedRepoProvider, ENV_SCOPE, DEPLOY_TRIGGER, DEPLOYMENT_STATUS, TOKEN_PURPOSE } from './chunk-LLRUOIMU.mjs';
+import { parseArgs, flagBool, flagString } from './chunk-XQAHREKO.mjs';
+import { ApiClient } from './chunk-CLQYPTJ2.mjs';
+import { readAuth, readProjectLink, writeProjectState } from './chunk-TT4YI33G.mjs';
+import { info, dim, step, CliError, CLI_ERROR_CODE, success, result, EXIT_CODE } from './chunk-KOD4GBQ5.mjs';
 import { spawn } from 'child_process';
 import { promises } from 'fs';
 import path from 'path';
@@ -90,11 +90,11 @@ Or deploy anyway with --${FLAG_SKIP_ENV_CHECK}.`
   );
 }
 function resolvePushStrategy(originUrl, linkRemoteUrl, repo) {
-  if (isFreestyleRemote(originUrl) || isFreestyleRemote(linkRemoteUrl)) {
+  if (isManagedRemote(originUrl) || isManagedRemote(linkRemoteUrl)) {
     return { kind: "managed" };
   }
   if (repo) {
-    if (repo.provider === REPO_PROVIDER.FREESTYLE || isFreestyleRemote(repo.remote_url)) {
+    if (isManagedRepoProvider(repo.provider) || isManagedRemote(repo.remote_url)) {
       return { kind: "managed" };
     }
     if (!originUrl) {
@@ -117,7 +117,7 @@ Then re-run cimplify deploy.`
 }
 async function pushForDeploy(client, businessId, projectId, root, branch, linkRemoteUrl) {
   const originUrl = await gitGetRemoteUrl(root);
-  const repo = isFreestyleRemote(originUrl) || isFreestyleRemote(linkRemoteUrl) ? null : await fetchRepoRecord(client, businessId, projectId);
+  const repo = isManagedRemote(originUrl) || isManagedRemote(linkRemoteUrl) ? null : await fetchRepoRecord(client, businessId, projectId);
   const strategy = resolvePushStrategy(originUrl, linkRemoteUrl, repo);
   if (strategy.kind === "error") {
     throw new CliError(CLI_ERROR_CODE.GIT_ERROR, strategy.message);

package/dist/dev-MOYURRWQ.mjs

@@ -0,0 +1,401 @@
+#!/usr/bin/env node
+import { FRAME_MS, DEFAULT_EPOCH_MS, DEFAULT_SEED, SCRIPT_SCHEMA, DEVICES, DEFAULT_HOLD_FRAMES, DEFAULT_DRAG_FRAMES } from './chunk-KNPYBZ6B.mjs';
+import { startDevServer, devLocale, probeScript } from './chunk-BYNE553A.mjs';
+import './chunk-NY4YT7O6.mjs';
+import { localEnvironmentName } from './chunk-JEVSFNPT.mjs';
+import { localDataDir } from './chunk-SF44L2OD.mjs';
+import './chunk-VSA44UKR.mjs';
+import './chunk-EGQIPYUN.mjs';
+import './chunk-SCKQ4XSD.mjs';
+import './chunk-CPBESPWK.mjs';
+import './chunk-VHK7WBO3.mjs';
+import './chunk-5HP2INMY.mjs';
+import './chunk-JKECUAAV.mjs';
+import './chunk-THATLMEX.mjs';
+import './chunk-T4MW3PD4.mjs';
+import './chunk-KQNZKV6E.mjs';
+import { refreshEngineRuntime } from './chunk-G2ZEFSQJ.mjs';
+import './chunk-ZUCDXRFI.mjs';
+import './chunk-EYEMPIMP.mjs';
+import './chunk-AKACUJ3W.mjs';
+import './chunk-25ZPFHLF.mjs';
+import { formatDiagnostic } from './chunk-SGT5IJVW.mjs';
+import { parseArgs, flagBool, flagString } from './chunk-XQAHREKO.mjs';
+import { ApiClient } from './chunk-CLQYPTJ2.mjs';
+import { readAuthOrNull } from './chunk-TT4YI33G.mjs';
+import { info, bold, dim, CliError, CLI_ERROR_CODE, warn, failure, success } from './chunk-KOD4GBQ5.mjs';
+import path2 from 'path';
+import { promises } from 'fs';
+import { randomInt } from 'crypto';
+import { networkInterfaces } from 'os';
+
+var LINEAR_TOLERANCE = 0.01;
+function deviceName(start) {
+  const width = Math.round(start.width);
+  const height = Math.round(start.height);
+  const scale = Math.round(start.scale * 100) / 100;
+  for (const device of Object.values(DEVICES)) if (device.width === width && device.height === height && device.scale === scale) return device.name;
+  return `${width}x${height}@${scale}`;
+}
+function isPointer(event, kind) {
+  return event !== void 0 && event.kind === kind;
+}
+function at(event) {
+  return [event.x, event.y];
+}
+function same(a, b) {
+  return Math.abs(a[0] - b[0]) <= LINEAR_TOLERANCE && Math.abs(a[1] - b[1]) <= LINEAR_TOLERANCE;
+}
+function coalesce(events) {
+  const out = [];
+  for (const event of events) {
+    const last = out[out.length - 1];
+    if (event.kind === "move" && last !== void 0 && last.kind === "move" && last.frame === event.frame) out[out.length - 1] = event;
+    else if (event.kind === "text" && last !== void 0 && last.kind === "text" && last.frame === event.frame) out[out.length - 1] = { kind: "text", frame: event.frame, text: last.text + event.text };
+    else out.push(event);
+  }
+  return out;
+}
+function freeFrom(events, index, frame) {
+  const next = events[index];
+  return next === void 0 || next.frame >= frame;
+}
+function tap(events, i) {
+  const down = events[i];
+  const up = events[i + 1];
+  if (!isPointer(down, "down") || !isPointer(up, "up")) return null;
+  const hold = up.frame - down.frame;
+  if (!freeFrom(events, i + 2, up.frame + 1)) return null;
+  return { step: hold === DEFAULT_HOLD_FRAMES ? { tap: at(down) } : { tap: at(down), hold }, used: 2, frames: hold + 1 };
+}
+function drag(events, i) {
+  const down = events[i];
+  if (!isPointer(down, "down")) return null;
+  const path3 = [];
+  let j = i + 1;
+  for (; ; ) {
+    const move = events[j];
+    if (!isPointer(move, "move") || move.frame !== down.frame + path3.length + 1) break;
+    path3.push(at(move));
+    j++;
+  }
+  const up = events[j];
+  const n = path3.length;
+  if (n === 0 || !isPointer(up, "up") || up.frame !== down.frame + n + 1) return null;
+  if (!freeFrom(events, j + 1, up.frame + 1)) return null;
+  const from = at(down);
+  const to = path3[n - 1];
+  const linear = path3.every((p, k) => same(p, [from[0] + (to[0] - from[0]) * (k + 1) / n, from[1] + (to[1] - from[1]) * (k + 1) / n]));
+  const step = linear ? { drag: n === DEFAULT_DRAG_FRAMES ? { from, to } : { from, to, frames: n } } : { drag: { from, to, path: path3 } };
+  return { step, used: j + 1 - i, frames: n + 2 };
+}
+function key(events, i) {
+  const down = events[i];
+  const up = events[i + 1];
+  if (down === void 0 || up === void 0 || down.kind !== "key_down" || up.kind !== "key_up" || up.key !== down.key) return null;
+  const hold = up.frame - down.frame;
+  if (!freeFrom(events, i + 2, up.frame + 1)) return null;
+  return { step: hold === DEFAULT_HOLD_FRAMES ? { key: down.key } : { key: down.key, hold }, used: 2, frames: hold + 1 };
+}
+function typed(events, i) {
+  const event = events[i];
+  if (event === void 0 || event.kind !== "text" || !freeFrom(events, i + 1, event.frame + 1)) return null;
+  return { step: { type: event.text }, used: 1, frames: 1 };
+}
+function primitive(event) {
+  switch (event.kind) {
+    case "down":
+      return { down: [event.x, event.y] };
+    case "move":
+      return { move: [event.x, event.y] };
+    case "up":
+      return { up: true };
+    case "key_down":
+      return { key_down: event.key };
+    case "key_up":
+      return { key_up: event.key };
+    case "text":
+      return { text: event.text };
+  }
+}
+function stepsFrom(recorded) {
+  const events = coalesce([...recorded].sort((a, b) => a.frame - b.frame));
+  const steps = [];
+  let cursor = 0;
+  let i = 0;
+  while (i < events.length) {
+    const event = events[i];
+    if (event.frame > cursor) {
+      steps.push({ wait: event.frame - cursor });
+      cursor = event.frame;
+    }
+    const match = tap(events, i) ?? drag(events, i) ?? key(events, i) ?? typed(events, i);
+    if (match === null) {
+      steps.push(primitive(event));
+      i++;
+      continue;
+    }
+    steps.push(match.step);
+    cursor += match.frames;
+    i += match.used;
+  }
+  return steps;
+}
+function recordedScript(start, events) {
+  return { schema: SCRIPT_SCHEMA, devices: [deviceName(start)], seed: start.seed, steps: stepsFrom(events) };
+}
+function isRecordedInput(value) {
+  if (typeof value !== "object" || value === null) return false;
+  const v = value;
+  const finite = (x) => typeof x === "number" && Number.isFinite(x);
+  const frame = finite(v.frame) && Number.isInteger(v.frame) && v.frame >= 0;
+  switch (v.kind) {
+    case "start":
+      return finite(v.width) && finite(v.height) && finite(v.scale) && finite(v.seed);
+    case "down":
+    case "move":
+    case "up":
+      return frame && finite(v.x) && finite(v.y);
+    case "key_down":
+    case "key_up":
+      return frame && typeof v.key === "string" && v.key.length > 0;
+    case "text":
+      return frame && typeof v.text === "string";
+    default:
+      return false;
+  }
+}
+var RECORD_MAX_NODES = 4096;
+function recordPrelude(seed) {
+  return `${probeScript({ seed, epoch: DEFAULT_EPOCH_MS, frame_ms: FRAME_MS, insets: null, bare: false, scene: null, max_nodes: RECORD_MAX_NODES, record: true })}
+`;
+}
+var InputRecorder = class {
+  constructor(file) {
+    this.file = file;
+  }
+  file;
+  start = null;
+  events = [];
+  writing = Promise.resolve();
+  dirty = false;
+  starts = 0;
+  get recording() {
+    return this.start !== null;
+  }
+  get count() {
+    return this.events.length;
+  }
+  add(inputs) {
+    let accepted = 0;
+    for (const input of inputs) {
+      if (!isRecordedInput(input)) continue;
+      accepted++;
+      if (input.kind === "start") {
+        this.start = input;
+        this.events = [];
+        this.starts++;
+      } else if (this.start !== null) this.events.push(input);
+    }
+    if (accepted > 0) this.dirty = true;
+    return accepted;
+  }
+  script() {
+    return this.start === null ? null : recordedScript(this.start, this.events);
+  }
+  flush() {
+    if (!this.dirty) return this.writing;
+    this.dirty = false;
+    const script = this.script();
+    if (script === null) return this.writing;
+    const text = `${JSON.stringify(script, null, 2)}
+`;
+    this.writing = this.writing.then(async () => {
+      await promises.mkdir(path2.dirname(this.file), { recursive: true });
+      await promises.writeFile(this.file, text);
+    });
+    return this.writing;
+  }
+};
+
+// src/interactives/dev/engine-session.ts
+var ENGINE_SESSIONS_ROUTE = "/v1/interactives/engine/sessions";
+var CLI_AUDIENCE = "cli";
+var CLI_ORIGIN = "cli";
+var REFRESH_MARGIN_MS = 5 * 60 * 1e3;
+var RETRY_AFTER_FAILURE_MS = 5 * 60 * 1e3;
+async function signedInClient() {
+  const auth = await readAuthOrNull();
+  return auth === null ? null : ApiClient.fromAuth(auth);
+}
+var DevEngineSessions = class {
+  constructor(client = signedInClient, now = Date.now, report2 = (message) => info(dim(message))) {
+    this.client = client;
+    this.now = now;
+    this.report = report2;
+  }
+  client;
+  now;
+  report;
+  held = null;
+  retryAt = 0;
+  reported = false;
+  async session() {
+    const at2 = this.now();
+    if (this.held !== null && this.held.expiresAt - REFRESH_MARGIN_MS > at2) return this.held.session;
+    if (at2 < this.retryAt) return null;
+    try {
+      const client = await this.client();
+      if (client === null) throw new Error("not signed in; run `cimplify login`");
+      const body = await client.post(ENGINE_SESSIONS_ROUTE, { audience: CLI_AUDIENCE });
+      const expiresAt = Date.parse(body.expires_at);
+      if (typeof body.token !== "string" || body.token.length === 0 || Number.isNaN(expiresAt)) throw new Error("the registry returned an unusable engine session");
+      this.held = { session: { token: body.token, audience: CLI_AUDIENCE, origin: CLI_ORIGIN }, expiresAt };
+      return this.held.session;
+    } catch (error) {
+      this.held = null;
+      this.retryAt = at2 + RETRY_AFTER_FAILURE_MS;
+      if (!this.reported) {
+        this.reported = true;
+        this.report(`Previewing without an engine session token: ${error instanceof Error ? error.message : String(error)}`);
+      }
+      return null;
+    }
+  }
+};
+var CODE_ALPHABET = "ABCDEFGHJKLMNPQRSTUVWXYZ23456789";
+var CODE_HALF = 3;
+function lanAddress() {
+  const nets = networkInterfaces();
+  for (const name of Object.keys(nets).sort()) {
+    for (const net of nets[name] ?? []) {
+      if (net.family === "IPv4" && !net.internal) return net.address;
+    }
+  }
+  return null;
+}
+function pairingCode() {
+  let out = "";
+  for (let i = 0; i < CODE_HALF * 2; i++) {
+    if (i === CODE_HALF) out += "-";
+    out += CODE_ALPHABET[randomInt(CODE_ALPHABET.length)];
+  }
+  return out;
+}
+var LAN_PREVIEW_RELAY = {
+  async register(localUrl, port) {
+    const address = lanAddress();
+    const code = pairingCode();
+    return { code, url: address === null ? localUrl : `http://${address}:${port}/?code=${code}`, relayed: false };
+  }
+};
+
+// src/interactives/commands/dev.ts
+var DEFAULT_PORT = 4300;
+var LOOPBACK = "127.0.0.1";
+var ALL_INTERFACES = "0.0.0.0";
+function parsePort(value) {
+  if (value === void 0) return DEFAULT_PORT;
+  const port = Number(value);
+  if (!Number.isInteger(port) || port < 0 || port > 65535) {
+    throw new CliError(CLI_ERROR_CODE.INVALID_INPUT, `--port must be a port number, got '${value}'`);
+  }
+  return port;
+}
+function report(build) {
+  if (build.lockUpdated) info(dim("Pinned newly used libraries in cimplify.lock"));
+  for (const d of build.result.diagnostics) (d.severity === "error" ? failure : warn)(formatDiagnostic(d));
+  if (build.result.ok) success(`Rebuilt ${dim(build.result.sourceDigest)}`);
+}
+function reportTick(event) {
+  switch (event.type) {
+    case "ready":
+      info(dim(`Tick room  running ${event.seats} seats at ${event.rate_hz} Hz with ${event.state_bytes} state bytes`));
+      return;
+    case "log":
+      info(dim(`[tick ${event.tick}] ${event.message}`));
+      return;
+    case "error":
+      failure(`Tick room ${event.kind.replaceAll("_", " ")} at tick ${event.tick}: ${event.message}${event.source === null ? "" : ` (${event.source})`}`);
+      return;
+    case "unavailable":
+      warn(event.message);
+      return;
+    default:
+      return;
+  }
+}
+function parseSeed(value) {
+  if (value === void 0) return DEFAULT_SEED;
+  const seed = Number(value);
+  if (!Number.isInteger(seed)) throw new CliError(CLI_ERROR_CODE.INVALID_INPUT, `--seed takes an integer, got '${value}'`);
+  return seed;
+}
+function recording(file, seed) {
+  if (file === void 0) {
+    if (seed !== void 0) throw new CliError(CLI_ERROR_CODE.INVALID_INPUT, "--seed applies to --record; pass --record <file> too");
+    return null;
+  }
+  const target = path2.resolve(process.cwd(), file);
+  let last = 0;
+  return {
+    recorder: new InputRecorder(target),
+    prelude: recordPrelude(parseSeed(seed)),
+    onInput: (recorder) => {
+      if (recorder.starts === last) return;
+      last = recorder.starts;
+      info(dim(`Recording  engine started; inputs go to ${path2.relative(process.cwd(), target) || target}`));
+    }
+  };
+}
+async function run(argv) {
+  const args = parseArgs(argv);
+  const lan = flagBool(args, "lan");
+  const environment = localEnvironmentName(flagString(args, "env"));
+  const record = recording(flagString(args, "record"), flagString(args, "seed"));
+  await refreshEngineRuntime(process.cwd());
+  const server = await startDevServer({
+    root: process.cwd(),
+    host: lan ? ALL_INTERFACES : LOOPBACK,
+    port: parsePort(flagString(args, "port")),
+    contentOrigin: flagString(args, "content-origin"),
+    watch: true,
+    onRebuild: report,
+    tick: { onEvent: reportTick },
+    engineSessions: new DevEngineSessions(),
+    environment,
+    record,
+    locale: devLocale({
+      language: flagString(args, "locale"),
+      currency: flagString(args, "currency"),
+      timeZone: flagString(args, "time-zone")
+    })
+  });
+  report(server.current());
+  info("");
+  info(`Simulator  ${bold(server.url)}`);
+  if (record !== null) {
+    info(`Recording  ${bold(path2.relative(process.cwd(), record.recorder.file) || record.recorder.file)}  taps, drags, keys and text by frame, with a fixed clock and seed`);
+    info(dim("           replay it with cimplify capture --script <file>; a reload starts a new recording"));
+  }
+  info(dim(`Data       ${localDataDir(process.cwd(), environment)} (cimplify env reset ${environment} clears it)`));
+  if (lan) {
+    const link = await LAN_PREVIEW_RELAY.register(server.url, server.port);
+    info(`Phone      ${bold(link.url)}  code ${bold(link.code)}`);
+    info(dim("           open it on a phone on the same network; the hosted preview relay is not live yet"));
+  } else {
+    info(dim("Phone      run with --lan to preview on a phone on the same network"));
+  }
+  info(dim("Watching for changes. Press Ctrl+C to stop."));
+  await new Promise((resolve) => {
+    const stop = () => {
+      process.off("SIGINT", stop);
+      process.off("SIGTERM", stop);
+      void server.close().then(resolve);
+    };
+    process.on("SIGINT", stop);
+    process.on("SIGTERM", stop);
+  });
+}
+
+export { run as default };

package/dist/dev-WL43Q7VD.mjs

@@ -0,0 +1,8 @@
+#!/usr/bin/env node
+export { run as default, detectPackageManager, mergeEnvEntries } from './chunk-LNMITJ4Z.mjs';
+import './chunk-SAXGWS2K.mjs';
+import './chunk-LLRUOIMU.mjs';
+import './chunk-XQAHREKO.mjs';
+import './chunk-CLQYPTJ2.mjs';
+import './chunk-TT4YI33G.mjs';
+import './chunk-KOD4GBQ5.mjs';