create-astrale-domain 0.1.4 → 0.1.6

package/dist/index.js

@@ -789,23 +789,25 @@ var require2 = createRequire(import.meta.url);
 var HERE = dirname(fileURLToPath(import.meta.url));
 var WORKSPACE_ROOT = join(HERE, "..", "..", "..");
 var ORIGIN_PLACEHOLDER = "astrale-domain.example.dev";
+var INSTANCE_PLACEHOLDER = "my-instance-slug";
 var LINK_TARGETS = {
   "@astrale-os/sdk": "sdk",
-  "@astrale-os/devkit": "sdk/devkit",
   "@astrale-os/adapter-cloudflare": "sdk/adapter-cloudflare",
+  "@astrale-os/adapter-astrale": "sdk/adapter-astrale",
   "@astrale-os/kernel-core": "kernel/core",
   "@astrale-os/kernel-dsl": "kernel/dsl"
 };
+var BODY_PACKAGE = "@astrale-os/adapter-cloudflare";
 var ADAPTER_PACKAGES = {
+  astrale: "@astrale-os/adapter-astrale",
   cloudflare: "@astrale-os/adapter-cloudflare"
 };
-function templateDir(adapter) {
-  const pkg = ADAPTER_PACKAGES[adapter];
-  if (!pkg) throw new Error(`No template package registered for adapter "${adapter}".`);
+var ADAPTER_DEP_RANGE = ">=0.1.0 <1.0.0";
+function templateDir(pkg) {
   return join(dirname(require2.resolve(`${pkg}/package.json`)), "template");
 }
 async function scaffold(opts) {
-  const src = templateDir(opts.adapter);
+  const src = templateDir(BODY_PACKAGE);
   if (!existsSync(src)) {
     throw new Error(`Template not found at ${src}.`);
   }
@@ -817,6 +819,7 @@ async function scaffold(opts) {
     recursive: true,
     filter: (s) => !/\/(node_modules|\.astrale|dist-client|\.wrangler)(\/|$)/.test(`/${relative(src, s)}`)
   });
+  await materializeAdapter(opts);
   await stampOrigin(opts.dir, opts.origin);
   await rewritePackageJson(opts.dir, opts.name, opts.link);
   await writeFile(
@@ -840,6 +843,24 @@ async function stampOrigin(dir, origin) {
   const config = join(dir, "astrale.config.ts");
   await replaceInFile(config, ORIGIN_PLACEHOLDER, origin);
 }
+async function materializeAdapter(opts) {
+  if (opts.adapter !== "astrale") return;
+  const config = join(opts.dir, "astrale.config.ts");
+  await cp(join(templateDir(ADAPTER_PACKAGES.astrale), "astrale.config.ts"), config);
+  await setAdapterDep(opts.dir, "@astrale-os/adapter-cloudflare", "@astrale-os/adapter-astrale");
+  if (opts.instance) await replaceInFile(config, `'${INSTANCE_PLACEHOLDER}'`, `'${opts.instance}'`);
+}
+async function setAdapterDep(dir, from, to) {
+  const path = join(dir, "package.json");
+  const pkg = JSON.parse(await readFile(path, "utf-8"));
+  if (!pkg.dependencies || !(from in pkg.dependencies)) return;
+  delete pkg.dependencies[from];
+  pkg.dependencies[to] = ADAPTER_DEP_RANGE;
+  pkg.dependencies = Object.fromEntries(
+    Object.entries(pkg.dependencies).sort(([a], [b3]) => a.localeCompare(b3))
+  );
+  await writeFile(path, JSON.stringify(pkg, null, 2) + "\n");
+}
 async function rewritePackageJson(dir, name, link) {
   const path = join(dir, "package.json");
   const pkg = JSON.parse(await readFile(path, "utf-8"));
@@ -877,18 +898,53 @@ export {}
     `import { defineSchema, KernelSchema } from '@astrale-os/kernel-core'
 
 export const schema = defineSchema('${origin}', {
+  interfaces: {},
+  classes: {},
   imports: [KernelSchema],
 })
 `
   );
   await writeFile(
-    join(dir, "methods", "index.ts"),
+    join(dir, "env.ts"),
+    `/**
+ * Worker runtime env. The adapter injects \`WORKER_URL\` and the bindings; your
+ * handlers receive this (mapped by deps.ts) as \`ctx.deps\`. Secrets from
+ * \`.env.<env>\` arrive as extra string fields here. Add typed fields as you
+ * reference new secrets/vars.
+ */
+export interface Env {
+  WORKER_URL?: string
+  ASSETS?: { fetch(request: Request): Promise<Response> }
+  SELF?: { fetch(request: Request): Promise<Response> }
+  VIEW_DEV_URL?: string
+  [key: string]: unknown
+}
+`
+  );
+  await writeFile(
+    join(dir, "deps.ts"),
+    `/**
+ * env \u2192 handler dependency container (the seam \`defineDomain({ deps })\` mounts).
+ * Passthrough by default; transform here the moment a handler should depend on a
+ * PORT (built from \`integrations/\`) instead of raw env.
+ */
+import type { Env } from './env'
+
+export interface Deps extends Env {}
+
+export function deps(env: Env): Deps {
+  return env
+}
+`
+  );
+  await writeFile(
+    join(dir, "runtime", "index.ts"),
     `import type { SchemaMethodsImpl } from '@astrale-os/sdk'
 
-import type { Env } from '../env'
+import type { Deps } from '../deps'
 import { schema } from '../schema'
 
-export const methods: SchemaMethodsImpl<typeof schema, Env> = {}
+export const methods: SchemaMethodsImpl<typeof schema, Deps> = { class: {} }
 `
   );
   await writeFile(join(dir, "functions", "index.ts"), `export const functions = {}
@@ -896,12 +952,12 @@ export const methods: SchemaMethodsImpl<typeof schema, Env> = {}
   await writeFile(join(dir, "views", "index.ts"), `export const views = {}
 `);
   await rm(join(dir, "schema", "compiled.ts"), { force: true });
-  await rm(join(dir, "methods", "note.ts"), { force: true });
-  await rm(join(dir, "functions", "seed.ts"), { force: true });
+  await rm(join(dir, "core"), { recursive: true, force: true });
+  await rm(join(dir, "integrations"), { recursive: true, force: true });
   await rm(join(dir, "views", "welcome.ts"), { force: true });
   await rm(join(dir, "views", "note.ts"), { force: true });
   await replaceInFile(
-    join(dir, "astrale.config.ts"),
+    join(dir, "domain.ts"),
     /\n\s*postInstall: `\/:\$\{schema\.domain\}:class\.Note:seed`,/,
     ""
   );
@@ -913,7 +969,7 @@ async function replaceInFile(path, from, to) {
   if (next !== text) await writeFile(path, next);
 }
 function workspaceAvailable() {
-  return existsSync(join(WORKSPACE_ROOT, "sdk", "devkit", "package.json"));
+  return existsSync(join(WORKSPACE_ROOT, "sdk", "package.json"));
 }
 
 // src/index.ts
@@ -926,15 +982,15 @@ var DLX = {
 };
 var ADAPTERS = [
   {
-    value: "astrale-host",
-    label: "Astrale Worker",
-    hint: "deployed under /service on an Astrale host (soon)",
-    enabled: false
+    value: "astrale",
+    label: "Astrale managed",
+    hint: "publishes through the platform onto your instance \u2014 no Cloudflare account",
+    enabled: true
   },
   {
     value: "cloudflare",
     label: "Cloudflare Worker",
-    hint: "standalone worker (*.workers.dev / custom domain)",
+    hint: "your own CF account (*.workers.dev / custom domain)",
     enabled: true
   },
   { value: "custom", label: "Custom", hint: "bring your own adapter (soon)", enabled: false }
@@ -968,11 +1024,11 @@ async function main() {
   }
   let adapter = flags.adapter;
   if (!adapter) {
-    if (headless) adapter = "cloudflare";
+    if (headless) adapter = "astrale";
     else {
       const answer = await ve({
         message: "Where will it run?  (deployment adapter)",
-        initialValue: "cloudflare",
+        initialValue: "astrale",
         options: ADAPTERS.map((a) => ({
           value: a.value,
           label: a.enabled ? a.label : `${a.label}  (soon)`,
@@ -983,10 +1039,24 @@ async function main() {
       adapter = answer;
     }
   }
-  if (adapter !== "cloudflare") {
-    xe(`The "${adapter}" adapter is not available yet \u2014 only "cloudflare" is wired today.`);
+  if (adapter !== "astrale" && adapter !== "cloudflare") {
+    xe(`The "${adapter}" adapter is not available yet \u2014 use "astrale" or "cloudflare".`);
     return 1;
   }
+  let instance = flags.instance;
+  if (instance !== void 0 && !isValidSlug(instance)) {
+    xe(`Invalid --instance "${instance}". Use lowercase letters, digits, dots and dashes.`);
+    return 1;
+  }
+  if (adapter === "astrale" && !instance && !headless) {
+    const answer = await he({
+      message: "Target instance slug  (`astrale instance create <slug>` \u2014 empty to set it later)",
+      placeholder: "my-app",
+      validate: (v2) => !v2 || isValidSlug(v2) ? void 0 : "Use lowercase letters, digits, dots and dashes."
+    });
+    if (pD(answer)) return bail();
+    if (answer) instance = answer;
+  }
   let template = flags.template;
   if (!template) {
     if (headless) template = "template";
@@ -1043,8 +1113,9 @@ async function main() {
       dir,
       name: slug,
       origin,
-      adapter: "cloudflare",
+      adapter,
       template,
+      instance,
       link
     });
     s.stop(`Created ${dir}`);
@@ -1059,22 +1130,38 @@ async function main() {
   const rel = relative2(process.cwd(), dir);
   const cdTarget = rel && !rel.startsWith("..") ? rel : dir;
   Me(
-    [`cd ${cdTarget}`, `${pm} install`, devStep(pm), installStep(pm), prodStep(pm)].join("\n"),
+    [
+      `cd ${cdTarget}`,
+      `${pm} install`,
+      devStep(pm),
+      installStep(pm),
+      prodStep(pm, adapter, instance)
+    ].join("\n"),
     "Next"
   );
+  if (adapter === "astrale" && !instance) {
+    M2.warn(
+      `No target instance set \u2014 put your slug in astrale.config.ts (prod.instance) before \`${pm === "npm" ? "npm run prod" : `${pm} prod`}\`. Create one: astrale instance create <slug>`
+    );
+  }
   M2.info(
-    "AI agent on this project? The full authoring guide ships at .agents/skills/astrale-domain/SKILL.md"
+    `AI agent on this project? The full authoring guide ships at .agents/skills/astrale-domain/SKILL.md
+   Agent rooted at a parent workspace? Register the skills there:  npx skills add ${cdTarget === dir ? dir : `./${cdTarget}`}/.agents/skills -y`
   );
   Se(`\u2713 ${slug} ready`);
   return 0;
 }
 var devStep = (pm) => `${pm === "npm" ? "npm run dev" : `${pm} dev`}                          # wrangler dev \u2192 prints a local URL`;
-var prodStep = (pm) => `${pm === "npm" ? "npm run prod" : `${pm} prod`}                         # deploy prod \u2192 prints a URL`;
+var prodStep = (pm, adapter, instance) => {
+  const cmd = pm === "npm" ? "npm run prod" : `${pm} prod`;
+  const hint = adapter === "astrale" ? `# managed deploy \u2192 installs on ${instance ? `"${instance}"` : "your instance"}` : "# deploy prod \u2192 prints a URL";
+  return `${cmd}                         ${hint}`;
+};
 function installStep(pm) {
-  if (astraleOnPath()) return "astrale instance install <url>    # mount it on an instance";
+  if (astraleOnPath()) return "astrale domain install <url> --direct    # mount it on an instance";
   return [
     "# astrale CLI not found on PATH \u2014 run it on demand (no install):",
-    `${DLX[pm]} @astrale-os/astrale instance install <url>`,
+    `${DLX[pm]} @astrale-os/astrale domain install <url> --direct`,
     "# or install it globally: npm i -g @astrale-os/astrale"
   ].join("\n");
 }
@@ -1102,6 +1189,7 @@ function parseFlags(argv) {
     else if (a === "--pm") flags.pm = argv[++i];
     else if (a === "--dir") flags.dir = argv[++i];
     else if (a === "--origin") flags.origin = argv[++i];
+    else if (a === "--instance") flags.instance = argv[++i];
     else if (!a.startsWith("-")) flags.positional.push(a);
   }
   return flags;
@@ -1119,7 +1207,8 @@ Arguments:
   <slug>              domain name (lowercase letters, digits, dots, dashes)
 
 Options:
-  --adapter <id>      deployment adapter \u2014 cloudflare (default; others soon)
+  --adapter <id>      deployment adapter \u2014 astrale (managed, default) | cloudflare
+  --instance <slug>   target instance for managed deploys (astrale adapter)
   --template <kind>   template | blank   (default: template)
   --pm <pm>           pnpm | npm | yarn | bun   (default: detected, else pnpm)
   --dir <path>        target directory   (default: ./<slug>)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "create-astrale-domain",
-  "version": "0.1.4",
+  "version": "0.1.6",
   "description": "Scaffold a standalone Astrale domain — npm create astrale-domain",
   "keywords": [
     "astrale",
@@ -19,7 +19,8 @@
   "type": "module",
   "dependencies": {
     "@clack/prompts": "^0.11.0",
-    "@astrale-os/adapter-cloudflare": "^0.1.7"
+    "@astrale-os/adapter-cloudflare": "^0.1.9",
+    "@astrale-os/adapter-astrale": "^0.1.0"
   },
   "devDependencies": {
     "@astrale-os/ox": ">=0.1.0 <1.0.0",