@wenathlan/getry 2.0.154 → 2.0.158

package/tests/cli.test.ts

@@ -0,0 +1,300 @@
+/**
+ * cli — the scaffolding cli under real subprocess execution (the getry copy
+ * of the devthink lane): every command runs as a child process exactly like
+ * a consumer types it: init with piped answers, list show validate models
+ * keys export help. the runner spawns the owner face directly (tsx cli.ts)
+ * — the devthink entry keeps answering the same family through its compat
+ * shim, and that lane stays covered by the devthink battery.
+ */
+
+import { execFile } from "node:child_process";
+import { existsSync, mkdtempSync, readFileSync, rmSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { promisify } from "node:util";
+import { afterAll, describe, expect, it } from "vitest";
+
+const exec = promisify(execFile);
+
+/** the tests village sits inside the getry app folder, so the cli runner
+ * and its tsx binary resolve through the app root one hop up (the owner
+ * face answers from its own root the same way). */
+const tsxbin = join(import.meta.dirname, "..", "node_modules", ".bin", "tsx");
+const clits = join(import.meta.dirname, "..", "cli.ts");
+/** the tsx subprocess resolves the library specifiers through the explicit
+ * application tsconfig (the runner cwd sits in a scaffold workdir, and the
+ * tsconfig discovery that walks from the cwd would never find the app
+ * paths — the flag pins the resolution to the owner tree). */
+const tsconfigpath = join(import.meta.dirname, "..", "tsconfig.json");
+
+/** run the cli in a workdir with optional piped stdin */
+async function runcli(
+  workdir: string,
+  args: string[],
+  input = "",
+): Promise<{ stdout: string; stderr: string; code: number }> {
+  try {
+    const { stdout, stderr } = await exec(tsxbin, ["--tsconfig", tsconfigpath, clits, ...args], {
+      cwd: workdir,
+      env: { ...process.env, DEVTHINK_DATABASE_URL: `file:${join(workdir, "cli.db")}` },
+      maxBuffer: 10 * 1024 * 1024,
+    });
+    if (input) {
+      // promisified execFile does not feed stdin — handled by the caller via runcliwithinput
+    }
+    return { stdout, stderr, code: 0 };
+  } catch (err) {
+    const e = err as { stdout?: string; stderr?: string; code?: number };
+    return { stdout: e.stdout ?? "", stderr: e.stderr ?? "", code: e.code ?? 1 };
+  }
+}
+
+/** run the cli feeding piped stdin answers (the automation consumer flow) */
+async function runcliwithinput(
+  workdir: string,
+  args: string[],
+  input: string,
+): Promise<{ stdout: string; stderr: string; code: number }> {
+  return new Promise((resolve) => {
+    const child = execFile(tsxbin, ["--tsconfig", tsconfigpath, clits, ...args], {
+      cwd: workdir,
+      env: { ...process.env, DEVTHINK_DATABASE_URL: `file:${join(workdir, "cli.db")}` },
+      maxBuffer: 10 * 1024 * 1024,
+    });
+    child.stdin?.write(input);
+    child.stdin?.end();
+    let stdout = "";
+    let stderr = "";
+    child.stdout?.on("data", (d: Buffer) => {
+      stdout += d.toString();
+    });
+    child.stderr?.on("data", (d: Buffer) => {
+      stderr += d.toString();
+    });
+    child.on("close", (code) => resolve({ stdout, stderr, code: code ?? 0 }));
+  });
+}
+
+// ---------------------------------------------------------------------------
+// workspace — one temp dir hosts the whole consumer journey
+// ---------------------------------------------------------------------------
+
+const workdir = mkdtempSync(join(tmpdir(), "gateway-cli-"));
+
+afterAll(() => {
+  rmSync(workdir, { recursive: true, force: true });
+});
+
+// ---------------------------------------------------------------------------
+// help and unknown commands
+// ---------------------------------------------------------------------------
+
+describe("cli help", () => {
+  it("prints the usage banner with every command", async () => {
+    const { stdout, code } = await runcli(workdir, ["help"]);
+    expect(code).toBe(0);
+    expect(stdout).toContain("@wenathlan/devthink gateway");
+    expect(stdout).toContain("Usage: devthink gateway <command>");
+    for (const cmd of ["init", "add", "list", "show", "validate", "keys", "models", "serve", "export"]) {
+      expect(stdout).toContain(cmd);
+    }
+  });
+
+  it("bare invocation prints help", async () => {
+    const { stdout, code } = await runcli(workdir, []);
+    expect(code).toBe(0);
+    expect(stdout).toContain("Usage: devthink gateway <command>");
+  });
+
+  it("unknown commands fail with the usage", async () => {
+    const { stdout, code } = await runcli(workdir, ["definitely-not-a-command"]);
+    expect(code).toBe(1);
+    expect(stdout).toContain("unknown command");
+  });
+});
+
+// ---------------------------------------------------------------------------
+// init — the piped automation consumer flow
+// ---------------------------------------------------------------------------
+
+describe("cli init", () => {
+  it("scaffolds the full project from piped default answers", async () => {
+    // 30 blank lines cover every question — each falls back to its default
+    const { stdout, code } = await runcliwithinput(workdir, ["init"], "\n".repeat(30));
+    expect(code).toBe(0);
+    expect(stdout).toContain("init");
+    expect(existsSync(join(workdir, "config.mjs"))).toBe(true);
+    expect(existsSync(join(workdir, "schema.prisma"))).toBe(true);
+    expect(existsSync(join(workdir, "prismaconfig.ts"))).toBe(true);
+    expect(existsSync(join(workdir, ".env.example"))).toBe(true);
+    expect(stdout).toContain("config.mjs");
+    expect(stdout).toContain("schema.prisma");
+    expect(stdout).toContain("prismaconfig.ts");
+  });
+
+  it("the scaffold is .mjs — loadable by plain node in a typeless package", () => {
+    const cfg = readFileSync(join(workdir, "config.mjs"), "utf8");
+    expect(cfg).toContain("export const config");
+  });
+
+  it("the generated config carries the version and meta model", () => {
+    const cfg = readFileSync(join(workdir, "config.mjs"), "utf8");
+    expect(cfg).toContain("v1");
+    expect(cfg).toContain("devthink");
+    expect(cfg).toContain("custom");
+    expect(cfg).toContain("rotation");
+    expect(cfg).toContain("bearer");
+  });
+
+  it("the generated schema defines the chat message and key models", () => {
+    const schema = readFileSync(join(workdir, "schema.prisma"), "utf8");
+    expect(schema).toContain("model ChatMessage");
+    expect(schema).toContain("model ApiKey");
+    expect(schema).toContain("model NvidiaKey");
+    expect(schema).toContain("datasource db");
+  });
+
+  it("the prisma config resolves the schema and datasource url", () => {
+    const prismaconfig = readFileSync(join(workdir, "prismaconfig.ts"), "utf8");
+    expect(prismaconfig).toContain("schema.prisma");
+    expect(prismaconfig).toContain("DEVTHINK_DATABASE_URL");
+  });
+
+  it("the env example lists the derived env var", () => {
+    const env = readFileSync(join(workdir, ".env.example"), "utf8");
+    expect(env).toContain("CUSTOM_API_KEY=");
+  });
+
+  it("init refuses to overwrite without a yes answer", async () => {
+    const before = readFileSync(join(workdir, "config.mjs"), "utf8");
+    const { stdout, code } = await runcliwithinput(workdir, ["init"], "n\n");
+    expect(code).toBe(0);
+    expect(stdout).toContain("keeping existing config");
+    expect(readFileSync(join(workdir, "config.mjs"), "utf8")).toBe(before);
+  });
+});
+
+// ---------------------------------------------------------------------------
+// list show validate models — reading the scaffolded config
+// ---------------------------------------------------------------------------
+
+describe("cli list show validate models", () => {
+  it("list shows the version summary", async () => {
+    const { stdout, code } = await runcli(workdir, ["list"]);
+    expect(code).toBe(0);
+    expect(stdout).toContain("1 versions");
+    expect(stdout).toContain("v1");
+    expect(stdout).toContain("custom");
+  });
+
+  it("show prints one version detail", async () => {
+    const { stdout, code } = await runcli(workdir, ["show", "v1"]);
+    expect(code).toBe(0);
+    expect(stdout).toContain("providername");
+    expect(stdout).toContain("upstreams");
+  });
+
+  it("show of an unknown version fails", async () => {
+    const { code } = await runcli(workdir, ["show", "nope"]);
+    expect(code).toBe(1);
+  });
+
+  it("validate reports the scaffolded config valid", async () => {
+    const { stdout, code } = await runcli(workdir, ["validate"]);
+    expect(code).toBe(0);
+    expect(stdout).toContain("config is valid");
+  });
+
+  it("models lists the catalog and rotation pool", async () => {
+    const { stdout, code } = await runcli(workdir, ["models", "v1"]);
+    expect(code).toBe(0);
+    expect(stdout).toContain("models for v1");
+    expect(stdout).toContain("default-model");
+    expect(stdout).toContain("rotation pool");
+  });
+});
+
+// ---------------------------------------------------------------------------
+// keys — env instructions and the db seed script
+// ---------------------------------------------------------------------------
+
+describe("cli keys", () => {
+  it("without a db model it documents the env var", async () => {
+    const { stdout, code } = await runcli(workdir, ["keys", "v1"]);
+    expect(code).toBe(0);
+    expect(stdout).toContain("CUSTOM_API_KEY");
+    expect(stdout).toContain("comma separated");
+  });
+
+  it("keys of an unknown version fails", async () => {
+    const { code } = await runcli(workdir, ["keys", "nope"]);
+    expect(code).toBe(1);
+  });
+});
+
+// ---------------------------------------------------------------------------
+// export — the deployable scaffold
+// ---------------------------------------------------------------------------
+
+describe("cli export", () => {
+  it("exports the config and schema for deploy", async () => {
+    const { stdout, code } = await runcli(workdir, ["export", "--dir", "export"]);
+    expect(code).toBe(0);
+    expect(stdout).toContain("exported config.mjs");
+    expect(stdout).toContain("exported schema.prisma");
+    expect(existsSync(join(workdir, "export", "config.mjs"))).toBe(true);
+    expect(existsSync(join(workdir, "export", "schema.prisma"))).toBe(true);
+  });
+});
+
+// ---------------------------------------------------------------------------
+// db-backed keys — a second workspace with db key storage enabled
+// ---------------------------------------------------------------------------
+
+describe("cli init with db keys", () => {
+  const dbworkdir = mkdtempSync(join(tmpdir(), "gateway-cli-db-"));
+
+  it("scaffolds with database key storage and generates the seed script", async () => {
+    const answers = [
+      "1", // versions
+      "", // id → v1
+      "", // provider → custom
+      "", // baseurl → default
+      "", // auth → bearer
+      "", // required → default true
+      "", // envvar → CUSTOM_API_KEY
+      "y", // store keys in database
+      "apiKey", // db model
+      "1", // one model
+      "", // model id default
+      "", // context
+      "", // maxoutput
+      "n", // no rotation (single model)
+      "y", // retry
+      "", // max retries
+      "", // backoff base
+      "", // backoff cap
+      "n", // no shared context
+      "", // meta id → devthink
+      "", // gateway name
+      "", // description
+    ].join("\n");
+    const { code } = await runcliwithinput(dbworkdir, ["init"], `${answers}\n`);
+    expect(code).toBe(0);
+
+    const { stdout, code: keyscode } = await runcliwithinput(
+      dbworkdir,
+      ["keys", "v1"],
+      "2\nkey-aaaaaaaaaa\nkey-bbbbbbbbbb\n",
+    );
+    expect(keyscode).toBe(0);
+    expect(stdout).toContain("register keys");
+    const seed = join(dbworkdir, "tests", "seedkeys.mjs");
+    expect(existsSync(seed)).toBe(true);
+    const content = readFileSync(seed, "utf8");
+    expect(content).toContain("key-aaaaaaaaaa");
+    expect(content).toContain("key-bbbbbbbbbb");
+    expect(content).toContain("apiKey");
+    rmSync(dbworkdir, { recursive: true, force: true });
+  });
+});

package/tests/debonairlane.test.ts

@@ -1,8 +1,12 @@
 // # debonairlane.test — the debonair api lane of the family gateway (the
-// mount adapter contract): the thirteen-route catalog mirrors the debonair
-// gateway table in the family shape (first match wins, the params capture,
-// an empty capture never matches, the provider lanes answer absent), the
-// adapter translates the getry mount shape (the web request) into the
+// mount adapter contract): the nineteen-route catalog imports the debonair
+// gateway table from the owner's leaf module (the published
+// "@wenathlan/debonair/routetable" specifier bridged to the monorepo
+// source — the mirror era is over) in the family shape (first match wins,
+// the params capture, an empty capture never matches, the provider lanes
+// answer absent, the render, the recon and the tracks lanes the mirror
+// never saw now ride, the generate lane answers its real handler names),
+// the adapter translates the getry mount shape (the web request) into the
 // debonair gateway request (the json lane, the raw lane, the query record)
 // and the debonair answer back into the web response (the json body, the
 // blob stream with the digest headers, the standardized error shape, the
@@ -15,7 +19,6 @@ import assert from "node:assert/strict";
 import { describe, it } from "vitest";
 import {
   DEBONAIR_URL_ENV,
-  DEBONAIRROUTES,
   type DebonairDispatch,
   type DebonairGatewayAnswer,
   type DebonairGatewayRequest,
@@ -25,8 +28,9 @@ import {
   debonairrequest,
   debonairresponse,
   debonairserve,
-  matchdebonairpath,
-  matchdebonairroute,
+  matchpath,
+  matchroute,
+  routes,
 } from "../debonairlane.ts";
 
 /** the debonair origin the wire tests ride (a public https host — the law). */
@@ -64,41 +68,82 @@ function valueseat(value: (request: DebonairGatewayRequest) => unknown): {
   return engineseat((request) => ({ ok: true, status: 200, value: value(request) }));
 }
 
-describe("the debonair route catalog (the published contract mirror)", () => {
-  it("carries the thirteen debonair routes in the family shape", () => {
-    assert.equal(DEBONAIRROUTES.length, 13);
-    assert.deepEqual(DEBONAIRROUTES[0], { method: "POST", path: "/api/v1/ingest/upload", handler: "uploadIngest" });
-    assert.deepEqual(DEBONAIRROUTES[5], { method: "GET", path: "/api/v1/blob/:id", handler: "getBlob" });
-    assert.deepEqual(DEBONAIRROUTES[12], { method: "GET", path: "/api/v1/vitrine", handler: "listVitrine" });
-    for (const route of DEBONAIRROUTES) {
+describe("the debonair route catalog (the owner's table imported through the leaf)", () => {
+  it("carries the nineteen debonair routes in the family shape (the real table, the real handler names)", () => {
+    assert.equal(routes.length, 19);
+    assert.deepEqual(routes[0], { method: "POST", path: "/api/v1/ingest/upload", handler: "uploadIngest" });
+    assert.deepEqual(routes[5], { method: "GET", path: "/api/v1/blob/:id", handler: "getBlob" });
+    assert.deepEqual(routes[9], { method: "POST", path: "/api/v1/render", handler: "queueRender" });
+    assert.deepEqual(routes[11], { method: "POST", path: "/api/v1/recon", handler: "queueRecon" });
+    assert.deepEqual(routes[13], { method: "POST", path: "/api/v1/tracks", handler: "publishTrack" });
+    assert.deepEqual(routes[14], { method: "GET", path: "/api/v1/tracks", handler: "listTracks" });
+    assert.deepEqual(
+      routes[15],
+      { method: "POST", path: "/api/v1/generate/render", handler: "queueGenerateRender" },
+      "the generate lane answers its real handler name (the mirror said queueRender)",
+    );
+    assert.deepEqual(
+      routes[16],
+      { method: "GET", path: "/api/v1/generate/jobs/:id", handler: "getGenerateJob" },
+      "the generate job poll answers its real handler name (the mirror said getRenderJob)",
+    );
+    assert.deepEqual(
+      routes[17],
+      { method: "POST", path: "/api/v1/tracks/:id/publish", handler: "publishTrackById" },
+      "the publish by id answers its real handler name (the mirror said publishTrack)",
+    );
+    assert.deepEqual(routes[18], { method: "GET", path: "/api/v1/vitrine", handler: "listVitrine" });
+    for (const route of routes) {
       assert.ok(route.path.startsWith("/api/v1/"), `${route.path} rides the api prefix`);
       assert.ok(["GET", "POST", "DELETE"].includes(route.method));
     }
   });
 
   it("matches the params, refuses the empty capture and answers the method verdict", () => {
-    const routed = matchdebonairroute("GET", "/api/v1/ingest/jobs/123");
+    const routed = matchroute("GET", "/api/v1/ingest/jobs/123");
     assert.ok(routed.kind === "routed");
     assert.equal(routed.route.handler, "getIngestJob");
     assert.deepEqual(routed.params, { id: "123" });
     // the empty capture never matches — a route param always carries a value
-    assert.equal(matchdebonairpath("/api/v1/blob/:id", "/api/v1/blob/"), null);
+    assert.equal(matchpath("/api/v1/blob/:id", "/api/v1/blob/"), null);
     // the specific rows ride first: the jobs row wins over the :id row
-    const shelf = matchdebonairroute("GET", "/api/v1/ingest");
+    const shelf = matchroute("GET", "/api/v1/ingest");
     assert.ok(shelf.kind === "routed" && shelf.route.handler === "listIngestShelf");
     // the path matches, the method does not — the allowed list answers
-    const method = matchdebonairroute("PUT", "/api/v1/vitrine");
+    const method = matchroute("PUT", "/api/v1/vitrine");
     assert.ok(method.kind === "method");
     assert.deepEqual(method.allowed, ["GET"]);
     // the provider lanes own their paths — the catalog answers absent
-    const foreign = matchdebonairroute("POST", "/v1/chat/completions");
+    const foreign = matchroute("POST", "/v1/chat/completions");
     assert.deepEqual(foreign, { kind: "absent" });
   });
 
+  it("routes the render, the recon and the tracks lanes the mirror never saw", () => {
+    const render = matchroute("POST", "/api/v1/render");
+    assert.ok(render.kind === "routed" && render.route.handler === "queueRender");
+    const renderjob = matchroute("GET", "/api/v1/render/jobs/9");
+    assert.ok(renderjob.kind === "routed" && renderjob.route.handler === "getRenderJob");
+    const recon = matchroute("POST", "/api/v1/recon");
+    assert.ok(recon.kind === "routed" && recon.route.handler === "queueRecon");
+    const reconjob = matchroute("GET", "/api/v1/recon/jobs/9");
+    assert.ok(reconjob.kind === "routed" && reconjob.route.handler === "getReconJob");
+    const publish = matchroute("POST", "/api/v1/tracks");
+    assert.ok(publish.kind === "routed" && publish.route.handler === "publishTrack");
+    const tracks = matchroute("GET", "/api/v1/tracks");
+    assert.ok(tracks.kind === "routed" && tracks.route.handler === "listTracks");
+    // the generate lane's own spellings route under the real handler names
+    const generate = matchroute("POST", "/api/v1/generate/render");
+    assert.ok(generate.kind === "routed" && generate.route.handler === "queueGenerateRender");
+    const generatejob = matchroute("GET", "/api/v1/generate/jobs/9");
+    assert.ok(generatejob.kind === "routed" && generatejob.route.handler === "getGenerateJob");
+    const publishbyid = matchroute("POST", "/api/v1/tracks/9/publish");
+    assert.ok(publishbyid.kind === "routed" && publishbyid.route.handler === "publishTrackById");
+  });
+
   it("decodes the captured params (the vault safeDecode law)", () => {
-    const params = matchdebonairpath("/api/v1/profiles/:genre", "/api/v1/profiles/drill%20beats");
+    const params = matchpath("/api/v1/profiles/:genre", "/api/v1/profiles/drill%20beats");
     assert.deepEqual(params, { genre: "drill beats" });
-    const malformed = matchdebonairpath("/api/v1/profiles/:genre", "/api/v1/profiles/%zz");
+    const malformed = matchpath("/api/v1/profiles/:genre", "/api/v1/profiles/%zz");
     assert.deepEqual(malformed, { genre: "%zz" }, "a malformed escape keeps the raw text");
   });
 });

package/tests/design.test.ts

@@ -20,15 +20,15 @@ function read(path: string): string {
   return readFileSync(new URL(path, import.meta.url), "utf8");
 }
 
-const CSS = read("../Sol/sol.css");
+const CSS = read("../sol/sol.css");
 const ENTRY = read("../index.html");
-const MARK = read("../Sol/wingets/ShellBrandmark.tsx");
-const SHELL = read("../Sol/shell/Shell.tsx");
-const SOL = read("../Sol/Sol.tsx");
-const HOME = read("../Sol/home/home.tsx");
-const GATE = read("../Sol/wingets/HomeEntrygate.tsx");
-const INTRO = read("../Sol/intro/intro.tsx");
-const ONBOARDING = read("../Sol/onboarding/onboarding.tsx");
+const MARK = read("../sol/wingets/ShellBrandmark.tsx");
+const SHELL = read("../sol/shell/Shell.tsx");
+const SOL = read("../sol/Sol.tsx");
+const HOME = read("../sol/home/home.tsx");
+const GATE = read("../sol/wingets/HomeEntrygate.tsx");
+const INTRO = read("../sol/intro/intro.tsx");
+const ONBOARDING = read("../sol/onboarding/onboarding.tsx");
 const STATE = read("../onboardingstate.ts");
 const DB = read("../db.ts");
 const SCHEMA = read("../schema.prisma");
@@ -197,7 +197,7 @@ describe("flow contract — intro → onboarding → the platform", () => {
 
   it("gates the home anchor on the seen state before anything shows", () => {
     /* the widget surface law: the dotted widget name is written exactly
-    once (inside Sol/wingets/index.ts) and the page answers the surface
+    once (inside sol/wingets/index.ts) and the page answers the surface
     import with its canonical alias — never the dotted path again */
     expect(HOME).toMatch(/import \{ HomeEntrygate as EntryGate \} from "\.\.\/wingets"/);
     expect(GATE).toContain('navigate("/intro", { replace: true })');