@domesystems/templates 0.1.0 → 0.1.1

package/ai-agent-for-documentation/template.yaml

@@ -106,6 +106,7 @@ app:
   runtime:
     pattern: chat
     language: python
+    image_tag: dev
   agent:
     prompt: app/instructions.md
     help: app/help.md

package/ai-agent-for-notion/template.yaml

@@ -115,6 +115,7 @@ app:
   runtime:
     pattern: chat
     language: python
+    image_tag: dev
   agent:
     prompt: app/instructions.md
     help: app/help.md

package/ai-agent-for-release-notes/template.yaml

@@ -122,6 +122,7 @@ app:
   runtime:
     pattern: run
     language: python
+    image_tag: dev
   agent:
     prompt: app/instructions.md
     help: app/help.md

package/bin/dome-templates.mjs

@@ -2,4 +2,4 @@
 
 import { main } from "../src/cli.mjs";
 
-main(process.argv.slice(2));
+await main(process.argv.slice(2));

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@domesystems/templates",
-  "version": "0.1.0",
+  "version": "0.1.1",
   "description": "Initialize and run Dome governed-agent templates.",
   "type": "module",
   "bin": {

package/src/cli.mjs

@@ -1,7 +1,8 @@
 import fs from "node:fs";
 import path from "node:path";
 import { fileURLToPath } from "node:url";
-import { spawnSync } from "node:child_process";
+import { spawn, spawnSync } from "node:child_process";
+import readline from "node:readline/promises";
 import { readManifest } from "./manifest.mjs";
 import { imageForRuntime, renderCompose } from "./runtime.mjs";
 import { copyTemplate, initializeEnvironment } from "./template-files.mjs";
@@ -67,7 +68,11 @@ function init(slug, options, output) {
   copyTemplate(source, target);
   const environmentCreated = initializeEnvironment(target);
   output(`Initialized ${slug} in ${target}.`);
-  if (environmentCreated) output("Created .env from .env.example. Add the required values before a live run.");
+  if (environmentCreated) {
+    output("Created .env from .env.example.");
+    output("When you run `up`, Dome will prompt for import credentials; they are never written to .env.");
+    output("After import, `up` writes DOME_TOKEN and DOME_GATEWAY_URL into .env. Add any other template-specific runtime values before starting.");
+  }
   return target;
 }
 
@@ -83,7 +88,117 @@ function run(command, args, cwd) {
   if (result.status !== 0) throw new Error(`${command} ${args.join(" ")} exited with status ${result.status}.`);
 }
 
-export function main(argv, { output = console.log, error = console.error } = {}) {
+function parseFinalJSON(output, command) {
+  const starts = [...output.matchAll(/(?:^|\n)\{/g)].map((match) => match.index + (match[0][0] === "\n" ? 1 : 0));
+  for (const start of starts.reverse()) {
+    try {
+      return JSON.parse(output.slice(start));
+    } catch {
+      // The CLI may have printed an interactive prompt before its final JSON result.
+    }
+  }
+  throw new Error(`${command} completed without a readable JSON result.`);
+}
+
+function runJSON(command, args, cwd, { displayOutput = true } = {}) {
+  return new Promise((resolve, reject) => {
+    const child = spawn(command, args, { cwd, stdio: ["inherit", "pipe", "inherit"] });
+    let output = "";
+    child.stdout.on("data", (chunk) => {
+      const text = chunk.toString();
+      output += text;
+      if (displayOutput) process.stdout.write(text);
+    });
+    child.on("error", (error) => reject(new Error(`Could not run ${command}: ${error.message}`)));
+    child.on("close", (status) => {
+      if (status !== 0) {
+        reject(new Error(`${command} ${args.join(" ")} exited with status ${status}.`));
+        return;
+      }
+      try {
+        resolve(parseFinalJSON(output, command));
+      } catch (error) {
+        reject(error);
+      }
+    });
+  });
+}
+
+function replaceEnvironmentValue(source, name, value) {
+  const expression = new RegExp(`^${name}=.*$`, "m");
+  if (!expression.test(source)) throw new Error(`The runtime .env is missing ${name}.`);
+  return source.replace(expression, `${name}=${JSON.stringify(value)}`);
+}
+
+function undefinedEnvironmentValues(source) {
+  return source
+    .split(/\r?\n/)
+    .map((line) => line.match(/^([A-Za-z_][A-Za-z0-9_]*)=(?:\s*|""|''|undefined)$/)?.[1])
+    .filter(Boolean);
+}
+
+async function fillRuntimeEnvironment(target, output) {
+  const environmentPath = path.join(target, ".env");
+  let environment = fs.readFileSync(environmentPath, "utf8");
+  const missing = undefinedEnvironmentValues(environment);
+  if (missing.length === 0) return;
+  if (!process.stdin.isTTY || !process.stdout.isTTY) {
+    throw new Error(`Missing runtime .env values: ${missing.join(", ")}. Set them before starting Docker.`);
+  }
+
+  output(`Complete ${environmentPath} before starting the app.`);
+  const terminal = readline.createInterface({ input: process.stdin, output: process.stdout, terminal: true });
+  const write = terminal._writeToOutput.bind(terminal);
+  terminal._writeToOutput = (text) => {
+    if (text === "\n" || text === "\r\n") write(text);
+  };
+  try {
+    for (const name of missing) {
+      const value = (await terminal.question(`Enter ${name}: `)).trim();
+      if (!value) throw new Error(`${name} is required to start the app.`);
+      environment = replaceEnvironmentValue(environment, name, value);
+    }
+  } finally {
+    terminal.close();
+  }
+  fs.writeFileSync(environmentPath, environment);
+  output(`Saved runtime values to ${environmentPath}.`);
+}
+
+function gatewayURL(response) {
+  return response.data?.gateway?.endpoints?.gatewayUrl ?? response.data?.gateway?.endpoints?.gateway_url;
+}
+
+async function writeRuntimeEnvironment(target, manifest, importResponse, output) {
+  const jobID = importResponse.data?.job?.id;
+  if (!jobID) throw new Error("Dome import succeeded but did not return an import job ID.");
+
+  const gatewayName = manifest.catalog?.gateway?.name;
+  if (!gatewayName) throw new Error("template.yaml must declare catalog.gateway.name to configure the runtime.");
+
+  const environmentPath = path.join(target, ".env");
+  let environment = fs.readFileSync(environmentPath, "utf8");
+  // Validate the local contract before consuming a one-time secret.
+  for (const name of ["DOME_TOKEN", "DOME_GATEWAY_URL"]) {
+    if (!new RegExp(`^${name}=.*$`, "m").test(environment)) throw new Error(`The runtime .env is missing ${name}.`);
+  }
+
+  const gateway = await runJSON("dome", ["gateways", "get", gatewayName, "--format", "json"], target, { displayOutput: false });
+  const url = gatewayURL(gateway);
+  if (!url) throw new Error(`Gateway ${gatewayName} has no runtime endpoint.`);
+
+  const revealed = await runJSON("dome", ["import", "outputs", jobID, "--format", "json"], target, { displayOutput: false });
+  const outputs = revealed.data?.outputs ?? {};
+  const tokens = Object.entries(outputs).filter(([name, value]) => name.endsWith("_token") && value);
+  if (tokens.length !== 1) throw new Error("The import must produce exactly one *_token output to configure DOME_TOKEN.");
+
+  environment = replaceEnvironmentValue(environment, "DOME_TOKEN", tokens[0][1]);
+  environment = replaceEnvironmentValue(environment, "DOME_GATEWAY_URL", url);
+  fs.writeFileSync(environmentPath, environment);
+  output(`Configured ${environmentPath} with the one-time agent token and Gateway URL.`);
+}
+
+export async function main(argv, { output = console.log, error = console.error } = {}) {
   try {
     const parsed = parseArguments(argv);
     if (parsed.help) {
@@ -102,8 +217,12 @@ export function main(argv, { output = console.log, error = console.error } = {})
     fs.writeFileSync(composePath, renderCompose(manifest.app.runtime));
     output(`Generated ${path.basename(composePath)} using ${imageForRuntime(manifest.app.runtime)}.`);
 
-    if (options.provision) run("dome", ["import", "dome.tf"], target);
+    if (options.provision) {
+      const imported = await runJSON("dome", ["import", "dome.tf", "--format", "json"], target);
+      await writeRuntimeEnvironment(target, manifest, imported, output);
+    }
     if (options.start) {
+      await fillRuntimeEnvironment(target, output);
       const args = ["compose", "-f", ".dome-compose.yaml", "up"];
       if (options.detach) args.push("--detach");
       run("docker", args, target);