@frockbot/applet-sdk 0.5.2 → 0.6.1

package/src/cli/bin.ts

@@ -1,128 +0,0 @@
-/**
- * `applet` — the four commands a Bot runs on the Computer.
- *
- * `scripts/build-cli.ts` bundles `./main.ts` (which calls `run` below) into
- * `dist/cli.mjs`, and that file is the package's `bin`: the Computer image has
- * Node and no Bun, and these sources are TypeScript resolving siblings through
- * `.js` specifiers, which plain Node cannot load.
- *
- *   applet new <name> [--dir <parent>]
- *   applet check [dir]
- *   applet build [dir]
- *   applet dev   [dir] [--port <n>]
- *
- * Output is deliberately spare: diagnostics as `path:line:col message`, one
- * per line, and a non-zero exit when any of them is an error. That is the whole
- * contract a Bot has to remember about this CLI.
- */
-
-import { resolve } from "node:path";
-
-import { formatDiagnostic } from "../lint/index.js";
-import { buildApplet } from "./build.js";
-import { checkApplet } from "./check.js";
-import { startAppletDev } from "./dev.js";
-import { newApplet } from "./new.js";
-
-const USAGE = `applet <command>
-
-  new <name> [--dir <parent>]   scaffold an Applet from the template
-  check [dir]                   type-check and lint
-  build [dir]                   write dist/{server.js,ui.html,manifest.json}
-  dev [dir] [--port <n>]        serve the built Applet locally
-`;
-
-interface Args {
-  command?: string;
-  positional: string[];
-  options: Record<string, string>;
-}
-
-export function parseArgs(argv: string[]): Args {
-  const positional: string[] = [];
-  const options: Record<string, string> = {};
-  for (let index = 0; index < argv.length; index += 1) {
-    const token = argv[index]!;
-    if (token.startsWith("--")) {
-      const [flag, inline] = token.slice(2).split("=", 2);
-      options[flag!] = inline ?? argv[++index] ?? "";
-      continue;
-    }
-    positional.push(token);
-  }
-  return { command: positional.shift(), positional, options };
-}
-
-function report(diagnostics: Awaited<ReturnType<typeof checkApplet>>): number {
-  for (const diagnostic of diagnostics)
-    console.error(formatDiagnostic(diagnostic));
-  const errors = diagnostics.filter(
-    (diagnostic) => diagnostic.severity === "error",
-  );
-  if (errors.length === 0) {
-    console.log("applet check: no problems found");
-    return 0;
-  }
-  console.error(`applet check: ${errors.length} error(s)`);
-  return 1;
-}
-
-export async function run(argv: string[]): Promise<number> {
-  const { command, positional, options } = parseArgs(argv);
-  const directory = resolve(positional[0] ?? ".");
-
-  switch (command) {
-    case "new": {
-      const name = positional[0];
-      if (!name) {
-        console.error("applet new needs a name");
-        return 2;
-      }
-      const created = await newApplet({
-        name,
-        parent: resolve(options.dir ?? "."),
-      });
-      console.log(`Created ${created.directory} (id ${created.id})`);
-      console.log("Next: applet check && applet build");
-      return 0;
-    }
-    case "check":
-      return report(await checkApplet(directory));
-    case "build": {
-      const result = await buildApplet(directory);
-      console.log(
-        `${result.serverPath} ${result.manifest.hashes.server.slice(0, 12)}`,
-      );
-      console.log(`${result.uiPath} ${result.manifest.hashes.ui.slice(0, 12)}`);
-      console.log(
-        `${result.manifestPath} ${result.manifest.tools.length} tool(s): ` +
-          result.manifest.tools.map((tool) => tool.name).join(", "),
-      );
-      return 0;
-    }
-    case "dev": {
-      const port = options.port === undefined ? 0 : Number(options.port);
-      if (!Number.isInteger(port) || port < 0 || port > 65_535) {
-        console.error("applet dev --port must be a port number");
-        return 2;
-      }
-      const server = await startAppletDev({ directory, port });
-      console.log(server.url.toString());
-      const stop = () => {
-        void server.dispose().then(() => process.exit(0));
-      };
-      process.on("SIGINT", stop);
-      process.on("SIGTERM", stop);
-      await new Promise(() => {});
-      return 0;
-    }
-    default:
-      console.log(USAGE);
-      return command === undefined || command === "help" ? 0 : 2;
-  }
-}
-
-// No `import.meta.main` guard: this module is the command table, and
-// `./main.ts` is the entry point the published `dist/cli.mjs` bundles. Two
-// entry points would run every command twice under a Node that implements
-// `import.meta.main`, which is exactly what happened before this comment.

package/src/cli/dev.ts

@@ -1,84 +0,0 @@
-/**
- * `applet dev` — the built Applet on a local port, ready to be opened and
- * screenshotted from the Computer's browser. It opens nothing itself.
- */
-
-import { randomUUID } from "node:crypto";
-import { readFile } from "node:fs/promises";
-import { join } from "node:path";
-
-import { readDescriptor } from "./manifest.js";
-import { startAppletRuntime, type AppletRuntime } from "./runtime.js";
-
-/**
- * In production the shell nests the Applet page and sends it `init`. There is
- * no shell here, so the dev page sends itself the same message — the page-side
- * contract is identical, which is the point of running it this way at all.
- */
-const DEV_THEME_TOKENS: Record<string, string> = {
-  surface: "#ffffff",
-  "surface-raised": "#ffffff",
-  "surface-subtle": "#f3f4f6",
-  text: "#16181d",
-  "text-muted": "#5b616b",
-  border: "#d8dbe0",
-  "accent-surface": "#2f6feb",
-  "accent-text": "#ffffff",
-  "radius-card": "10px",
-};
-
-function injectDevInit(
-  html: string,
-  token: string,
-  generationId: string,
-): string {
-  const init = {
-    schemaVersion: 1,
-    type: "init",
-    themeTokens: DEV_THEME_TOKENS,
-    packageId: "applets",
-    botId: "dev",
-    slot: "frockbot.right-panel",
-    applet: { socketUrl: "", token, generationId },
-  };
-  const script =
-    `<script>(()=>{const m=${JSON.stringify(init)};` +
-    `m.applet.socketUrl=location.origin.replace(/^http/,"ws")+"/socket";` +
-    `window.postMessage(m,"*");})();</script>`;
-  return html.replace("</body>", `${script}\n</body>`);
-}
-
-export interface AppletDevServer extends AppletRuntime {
-  token: string;
-}
-
-export interface AppletDevOptions {
-  directory: string;
-  /** 0 picks a free port. */
-  port?: number;
-}
-
-/** Serve `dist/` from Miniflare. Build first; this does not bundle. */
-export async function startAppletDev(
-  options: AppletDevOptions,
-): Promise<AppletDevServer> {
-  const descriptor = await readDescriptor(options.directory);
-  const dist = join(options.directory, "dist");
-  let serverCode: string;
-  let html: string;
-  try {
-    serverCode = await readFile(join(dist, "server.js"), "utf8");
-    html = await readFile(join(dist, "ui.html"), "utf8");
-  } catch {
-    throw new Error("No dist/ to serve; run `applet build` first");
-  }
-  const token = randomUUID();
-  const runtime = await startAppletRuntime({
-    serverCode,
-    html: injectDevInit(html, token, "dev"),
-    appletId: descriptor.id,
-    token,
-    port: options.port ?? 0,
-  });
-  return { ...runtime, token };
-}

package/src/cli/main.ts

@@ -1,17 +0,0 @@
-/**
- * The bundled CLI's entry point.
- *
- * `bin.ts` guards its own execution with `import.meta.main` so it can be
- * imported by tests under Bun. `dist/cli.mjs` is only ever executed, and it
- * runs under whatever Node the Computer image ships — where `import.meta.main`
- * may not exist, and where an absent guard would mean a CLI that exits 0 and
- * does nothing. So the bundle gets its own entry with no guard at all.
- */
-import { run } from "./bin.js";
-
-try {
-  process.exitCode = await run(process.argv.slice(2));
-} catch (error) {
-  console.error(error instanceof Error ? error.message : String(error));
-  process.exitCode = 1;
-}

package/src/cli/new.ts

@@ -1,74 +0,0 @@
-/** `applet new` — the template, with the name filled in. */
-
-import { mkdir, readdir, readFile, stat, writeFile } from "node:fs/promises";
-import { join } from "node:path";
-
-import { SDK_ROOT } from "./paths.js";
-
-const TEMPLATE_ROOT = join(SDK_ROOT, "template");
-
-/** `Weekly Plan` -> `weekly-plan`. */
-export function appletIdFrom(name: string): string {
-  const id = name
-    .trim()
-    .toLowerCase()
-    .replace(/[^a-z0-9]+/g, "-")
-    .replace(/^-+|-+$/g, "")
-    .slice(0, 32)
-    .replace(/-+$/g, "");
-  if (!/^[a-z][a-z0-9-]{0,31}$/.test(id)) {
-    throw new Error(`"${name}" does not yield a usable Applet id`);
-  }
-  return id;
-}
-
-function fill(text: string, id: string, displayName: string): string {
-  return text
-    .replaceAll("__APPLET_ID__", id)
-    .replaceAll("__APPLET_NAME__", displayName);
-}
-
-async function exists(path: string): Promise<boolean> {
-  try {
-    await stat(path);
-    return true;
-  } catch {
-    return false;
-  }
-}
-
-export interface NewAppletResult {
-  id: string;
-  displayName: string;
-  directory: string;
-  files: string[];
-}
-
-export async function newApplet(options: {
-  name: string;
-  /** Where the Applet directory is created; the durable root in production. */
-  parent: string;
-}): Promise<NewAppletResult> {
-  const id = appletIdFrom(options.name);
-  const directory = join(options.parent, id);
-  if (await exists(directory)) {
-    throw new Error(`${directory} already exists`);
-  }
-  const files: string[] = [];
-  const copy = async (from: string, to: string): Promise<void> => {
-    await mkdir(to, { recursive: true });
-    for (const entry of await readdir(from, { withFileTypes: true })) {
-      const source = join(from, entry.name);
-      const target = join(to, entry.name);
-      if (entry.isDirectory()) {
-        await copy(source, target);
-        continue;
-      }
-      const text = await readFile(source, "utf8");
-      await writeFile(target, fill(text, id, options.name), "utf8");
-      files.push(entry.name);
-    }
-  };
-  await copy(TEMPLATE_ROOT, directory);
-  return { id, displayName: options.name, directory, files };
-}