@astrale-os/cli 1.0.0-beta.3 → 1.0.0-beta.4

package/dist/astrale.js

@@ -9738,7 +9738,7 @@ var package_default;
 var init_package = __esm(() => {
   package_default = {
     name: "@astrale-os/cli",
-    version: "1.0.0-beta.3",
+    version: "1.0.0-beta.4",
     description: "Astrale CLI — connect to existing Astrale kernels",
     keywords: [
       "astrale",
@@ -67208,7 +67208,7 @@ function builtinIdpConfig(name, clientIdOverride, env2 = process.env) {
   };
 }
 function workosClientIdFromEnv(env2 = process.env) {
-  return WORKOS_CLIENT_ID_ENV_NAMES.map((name) => env2[name]?.trim()).find((value) => typeof value === "string" && value.length > 0);
+  return WORKOS_CLIENT_ID_ENV_NAMES.map((name) => env2[name]?.trim()).find((value) => typeof value === "string" && value.length > 0) ?? DEFAULT_WORKOS_CLIENT_ID;
 }
 async function fetchOAuthAuthorizationServerMetadata(issuer) {
   const discoveryUrl = new URL("/.well-known/oauth-authorization-server", issuer);
@@ -67553,7 +67553,7 @@ async function fetchWorkosApplication(args) {
 function normalizeIssuer(value) {
   return value.replace(/\/+$/, "");
 }
-var IdpAudienceMismatchError, OAuthTokenError, OidcMetadataSchema, IdpClientConfigSchema, IdpIndexEntrySchema, IdpStoreSchema, IdpSessionSchema, BUILTIN_WORKOS_IDP_NAME = "workos", DEFAULT_WORKOS_API_HOST = "https://api.workos.com", WORKOS_CLIENT_ID_ENV_NAMES;
+var IdpAudienceMismatchError, OAuthTokenError, OidcMetadataSchema, IdpClientConfigSchema, IdpIndexEntrySchema, IdpStoreSchema, IdpSessionSchema, BUILTIN_WORKOS_IDP_NAME = "workos", DEFAULT_WORKOS_API_HOST = "https://api.workos.com", DEFAULT_WORKOS_CLIENT_ID = "client_01KC29HET5F3QAQ8GNTPZ7F320", WORKOS_CLIENT_ID_ENV_NAMES;
 var init_idp = __esm(() => {
   init_webapi();
   init_zod2();
@@ -70394,7 +70394,257 @@ var init_instance2 = __esm(() => {
   });
 });
 
+// src/lib/proc.ts
+import { spawn } from "node:child_process";
+function run(file2, args = [], opts = {}) {
+  return new Promise((resolve3, reject) => {
+    const child3 = spawn(file2, args, { cwd: opts.cwd, stdio: ["ignore", "pipe", "pipe"] });
+    let stdout = "";
+    let stderr = "";
+    child3.stdout?.setEncoding("utf8");
+    child3.stderr?.setEncoding("utf8");
+    child3.stdout?.on("data", (chunk) => {
+      stdout += chunk;
+    });
+    child3.stderr?.on("data", (chunk) => {
+      stderr += chunk;
+    });
+    child3.on("error", reject);
+    child3.on("close", (code) => resolve3({ code: code ?? -1, stdout, stderr }));
+  });
+}
+function runInherit(file2, args = [], opts = {}) {
+  return new Promise((resolve3, reject) => {
+    const child3 = spawn(file2, args, { cwd: opts.cwd, stdio: "inherit" });
+    child3.on("error", reject);
+    child3.on("close", (code) => resolve3(code ?? -1));
+  });
+}
+function spawnHandle(file2, args = [], opts = {}) {
+  return spawn(file2, args, {
+    cwd: opts.cwd,
+    env: opts.env,
+    detached: opts.detached,
+    stdio: opts.stdio ?? ["ignore", "inherit", "inherit"]
+  });
+}
+var init_proc = () => {};
+
+// src/lib/update.ts
+import { createHash } from "node:crypto";
+import { chmod as chmod2, copyFile, mkdir as mkdir6, mkdtemp, readFile as readFile7, rename as rename2, rm, writeFile as writeFile2 } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { dirname as dirname6, join as join4 } from "node:path";
+function detectPlatform() {
+  const os2 = process.platform;
+  const arch = process.arch;
+  if (os2 !== "darwin" && os2 !== "linux") {
+    throw new AstraleError("UNSUPPORTED_PLATFORM", `Unsupported OS "${os2}" — Astrale update supports macOS and Linux.`);
+  }
+  if (arch !== "arm64" && arch !== "x64") {
+    throw new AstraleError("UNSUPPORTED_PLATFORM", `Unsupported CPU architecture "${arch}" — Astrale update supports arm64 and x64.`);
+  }
+  return { os: os2, arch };
+}
+function platformKey(platform) {
+  return `${platform.os}-${platform.arch}`;
+}
+function isStandaloneBinary() {
+  return Boolean(process.versions.bun);
+}
+async function readInstallMetadata(path3 = INSTALL_PATH) {
+  let raw2;
+  try {
+    raw2 = await readFile7(path3, "utf8");
+  } catch {
+    throw isStandaloneBinary() ? new AstraleError("UPDATE_NOT_SCRIPT_INSTALLED", "Astrale was not installed by the official install script.", "Reinstall with: curl -fsSL https://raw.githubusercontent.com/astrale-os/cli/main/install.sh | sh") : new AstraleError("UPDATE_PACKAGE_MANAGED", "This Astrale build is managed by your package manager.", "Update with: npm install -g @astrale-os/cli@latest  (or pnpm/bun)");
+  }
+  const parsed = InstallMetadataSchema.safeParse(JSON.parse(raw2));
+  if (!parsed.success) {
+    throw new AstraleError("UPDATE_BAD_INSTALL_METADATA", `Invalid install metadata at ${path3}.`, "Reinstall with: curl -fsSL https://raw.githubusercontent.com/astrale-os/cli/main/install.sh | sh");
+  }
+  return parsed.data;
+}
+async function writeInstallMetadata(meta3, path3 = INSTALL_PATH) {
+  await mkdir6(dirname6(path3), { recursive: true });
+  await writeFile2(path3, JSON.stringify(meta3, null, 2) + `
+`);
+}
+function releaseBase(meta3, req) {
+  if (process.env.ASTRALE_UPDATE_BASE)
+    return process.env.ASTRALE_UPDATE_BASE.replace(/\/+$/, "");
+  const repo = meta3.repo || DEFAULT_REPO;
+  if (req.version) {
+    const version2 = req.version.replace(/^cli\/v/, "").replace(/^v/, "");
+    return `https://github.com/${repo}/releases/download/cli/v${version2}`;
+  }
+  return `https://github.com/${repo}/releases/download/${req.channel ?? meta3.channel ?? DEFAULT_UPDATE_CHANNEL}`;
+}
+async function fetchManifest(base2) {
+  const raw2 = await readUrlText(`${base2}/manifest.json`);
+  return UpdateManifestSchema.parse(JSON.parse(raw2));
+}
+function shouldUpdate(currentVersion, manifestVersion) {
+  return currentVersion !== manifestVersion;
+}
+async function updateAstrale(req) {
+  const meta3 = await readInstallMetadata(req.installPath);
+  const currentVersion = meta3.version ?? req.currentVersion;
+  const channel = req.channel ?? meta3.channel ?? DEFAULT_UPDATE_CHANNEL;
+  const platform = req.platform ?? detectPlatform();
+  const key = platformKey(platform);
+  const base2 = releaseBase(meta3, { channel, version: req.version });
+  const manifest = await fetchManifest(base2);
+  const asset = manifest.assets[key];
+  if (!asset) {
+    throw new AstraleError("UPDATE_ASSET_NOT_FOUND", `No Astrale CLI release asset for ${key}.`, `Available platforms: ${Object.keys(manifest.assets).join(", ")}`);
+  }
+  if (!shouldUpdate(currentVersion, manifest.version)) {
+    return {
+      status: "up-to-date",
+      currentVersion,
+      latestVersion: manifest.version,
+      channel: manifest.channel
+    };
+  }
+  if (req.check) {
+    return {
+      status: "available",
+      currentVersion,
+      latestVersion: manifest.version,
+      channel: manifest.channel
+    };
+  }
+  const tmp = await mkdtemp(join4(tmpdir(), "astrale-update-"));
+  try {
+    const archive = join4(tmp, asset.name);
+    await downloadToFile(`${base2}/${asset.name}`, archive);
+    const manifestChecksum = "sha256" in asset ? asset.sha256 : undefined;
+    const expected = manifestChecksum ?? await fetchChecksum(base2, asset.name);
+    const actual = await sha256File(archive);
+    if (actual !== expected.toLowerCase()) {
+      throw new AstraleError("UPDATE_CHECKSUM_MISMATCH", `Checksum mismatch for ${asset.name}.`, `Expected ${expected}; got ${actual}.`);
+    }
+    await extractTarGz(archive, tmp);
+    const nextBin = join4(tmp, "astrale");
+    await chmod2(nextBin, 493);
+    await smokeVersion(nextBin, manifest.binaryVersion ?? manifest.version);
+    const previous = `${meta3.bin}.previous`;
+    const staged = `${meta3.bin}.next`;
+    await copyFile(meta3.bin, previous).catch(() => {
+      return;
+    });
+    await copyFile(nextBin, staged);
+    await chmod2(staged, 493);
+    await rename2(staged, meta3.bin);
+    await writeInstallMetadata({
+      ...meta3,
+      channel: manifest.channel,
+      version: manifest.version,
+      installedAt: new Date().toISOString()
+    }, req.installPath);
+    return {
+      status: "updated",
+      previousVersion: currentVersion,
+      currentVersion: manifest.version,
+      channel: manifest.channel,
+      bin: meta3.bin
+    };
+  } finally {
+    await rm(tmp, { recursive: true, force: true });
+  }
+}
+async function readUrlText(url3) {
+  if (url3.startsWith("file://")) {
+    return readFile7(new URL(url3), "utf8");
+  }
+  const res = await fetch(url3);
+  if (!res.ok)
+    throw new Error(`GET ${url3} failed: HTTP ${res.status}`);
+  return res.text();
+}
+async function downloadToFile(url3, path3) {
+  if (url3.startsWith("file://")) {
+    await copyFile(new URL(url3), path3);
+    return;
+  }
+  const res = await fetch(url3);
+  if (!res.ok)
+    throw new Error(`GET ${url3} failed: HTTP ${res.status}`);
+  const bytes = new Uint8Array(await res.arrayBuffer());
+  await writeFile2(path3, bytes);
+}
+async function fetchChecksum(base2, assetName) {
+  const raw2 = await readUrlText(`${base2}/sha256sums.txt`);
+  for (const line of raw2.split(/\r?\n/)) {
+    const [sha, file2] = line.trim().split(/\s+/, 2);
+    if (!sha || !file2)
+      continue;
+    if (file2.replace(/^\*/, "") === assetName && /^[a-fA-F0-9]{64}$/.test(sha))
+      return sha;
+  }
+  throw new AstraleError("UPDATE_CHECKSUM_NOT_FOUND", `Checksum entry not found for ${assetName}.`, `Release base: ${base2}`);
+}
+async function sha256File(path3) {
+  const hash2 = createHash("sha256");
+  hash2.update(await readFile7(path3));
+  return hash2.digest("hex");
+}
+async function extractTarGz(archive, cwd) {
+  const { code, stderr } = await run("tar", ["-xzf", archive, "-C", cwd]);
+  if (code !== 0) {
+    throw new Error(`Could not extract update archive: ${stderr.trim()}`);
+  }
+}
+async function smokeVersion(bin, expectedVersion) {
+  const { code, stdout, stderr } = await run(bin, ["--version"]);
+  if (code !== 0)
+    throw new Error(`Updated binary failed --version: ${stderr.trim()}`);
+  const actual = stdout.trim();
+  if (actual !== expectedVersion) {
+    throw new Error(`Updated binary reported version ${actual}, expected ${expectedVersion}`);
+  }
+}
+var DEFAULT_REPO = "astrale-os/cli", DEFAULT_UPDATE_CHANNEL = "beta", InstallMetadataSchema, ManifestAssetSchema, UpdateManifestSchema;
+var init_update = __esm(() => {
+  init_zod2();
+  init_errors2();
+  init_state();
+  init_proc();
+  InstallMetadataSchema = exports_external2.object({
+    method: exports_external2.literal("script"),
+    channel: exports_external2.string().min(1).default(DEFAULT_UPDATE_CHANNEL),
+    version: exports_external2.string().min(1).optional(),
+    repo: exports_external2.string().min(1).default(DEFAULT_REPO),
+    bin: exports_external2.string().min(1),
+    installedAt: exports_external2.string().optional()
+  });
+  ManifestAssetSchema = exports_external2.object({
+    name: exports_external2.string().min(1),
+    sha256: exports_external2.string().regex(/^[a-fA-F0-9]{64}$/).optional()
+  });
+  UpdateManifestSchema = exports_external2.object({
+    version: exports_external2.string().min(1),
+    binaryVersion: exports_external2.string().min(1).optional(),
+    channel: exports_external2.string().min(1),
+    repo: exports_external2.string().min(1).optional(),
+    assets: exports_external2.record(exports_external2.string(), exports_external2.union([
+      ManifestAssetSchema,
+      exports_external2.string().min(1).transform((name) => ({ name }))
+    ]))
+  });
+});
+
 // src/lib/admin-target.ts
+function defaultAdminTargetForChannel(channel) {
+  return channel === "stable" ? {
+    url: "https://admin.eu.astrale.ai/api",
+    domainIssuer: "https://admin.astrale.ai"
+  } : {
+    url: "https://admin.eu.beta.astrale.ai/api",
+    domainIssuer: "https://admin.beta.astrale.ai"
+  };
+}
 async function resolveAdminTarget(opts, config2, store) {
   return resolveAdminTargetFromStore(opts, config2, store ?? await readInstances());
 }
@@ -70486,12 +70736,16 @@ function requireDomainIssuer(value, label) {
     return value;
   throw new AstraleError("ADMIN_DOMAIN_ISSUER_MISSING", `${label} has no Domain issuer for token exchange.`, "Configure domainIssuer or pass --domain-issuer <url>; there is no legacy token fallback.");
 }
-var DEFAULT_ADMIN_TARGET_NAME = "admin", DEFAULT_ADMIN_TARGET_URL = "https://admin.eu.astrale.ai/api", DEFAULT_ADMIN_DOMAIN_ISSUER = "https://admin.beta.astrale.ai", DEFAULT_ADMIN_TARGET_CONFIG, HttpUrlSchema, AdminTargetConfigSchema, ADMIN_TARGET_OPTIONS;
+var DEFAULT_ADMIN_TARGET_NAME = "admin", DEFAULT_ADMIN_TARGET, DEFAULT_ADMIN_TARGET_URL, DEFAULT_ADMIN_DOMAIN_ISSUER, DEFAULT_ADMIN_TARGET_CONFIG, HttpUrlSchema, AdminTargetConfigSchema, ADMIN_TARGET_OPTIONS;
 var init_admin_target = __esm(() => {
   init_zod2();
   init_errors2();
   init_instance2();
+  init_update();
   init_validation2();
+  DEFAULT_ADMIN_TARGET = defaultAdminTargetForChannel(DEFAULT_UPDATE_CHANNEL);
+  DEFAULT_ADMIN_TARGET_URL = DEFAULT_ADMIN_TARGET.url;
+  DEFAULT_ADMIN_DOMAIN_ISSUER = DEFAULT_ADMIN_TARGET.domainIssuer;
   DEFAULT_ADMIN_TARGET_CONFIG = {
     name: DEFAULT_ADMIN_TARGET_NAME,
     url: DEFAULT_ADMIN_TARGET_URL,
@@ -70553,11 +70807,11 @@ var init_admin_target = __esm(() => {
 });
 
 // src/lib/config.ts
-import { readFile as readFile7, writeFile as writeFile2, mkdir as mkdir6 } from "node:fs/promises";
-import { dirname as dirname6 } from "node:path";
+import { readFile as readFile8, writeFile as writeFile3, mkdir as mkdir7 } from "node:fs/promises";
+import { dirname as dirname7 } from "node:path";
 async function readConfig() {
   try {
-    const raw2 = await readFile7(CONFIG_PATH, "utf-8");
+    const raw2 = await readFile8(CONFIG_PATH, "utf-8");
     return AstraleConfigSchema.parse(JSON.parse(raw2));
   } catch (e) {
     if (e instanceof exports_external2.ZodError || e instanceof SyntaxError) {
@@ -70567,8 +70821,8 @@ async function readConfig() {
   }
 }
 async function writeConfig(config2) {
-  await mkdir6(dirname6(CONFIG_PATH), { recursive: true });
-  await writeFile2(CONFIG_PATH, JSON.stringify(config2, null, 2) + `
+  await mkdir7(dirname7(CONFIG_PATH), { recursive: true });
+  await writeFile3(CONFIG_PATH, JSON.stringify(config2, null, 2) + `
 `);
 }
 var AstraleConfigSchema, DEFAULT_CONFIG;
@@ -70754,13 +71008,13 @@ function readline() {
 function withUpdates(fn2) {
   const wrapped = (...args) => {
     const store = getStore();
-    let shouldUpdate = false;
+    let shouldUpdate2 = false;
     const oldHandleChange = store.handleChange;
     store.handleChange = () => {
-      shouldUpdate = true;
+      shouldUpdate2 = true;
     };
     const returnValue = fn2(...args);
-    if (shouldUpdate) {
+    if (shouldUpdate2) {
       oldHandleChange();
     }
     store.handleChange = oldHandleChange;
@@ -82156,7 +82410,7 @@ function parseEditorCommand(editor) {
 }
 
 // node_modules/.pnpm/@inquirer+external-editor@3.0.3_@types+node@22.20.0/node_modules/@inquirer/external-editor/dist/index.js
-import { spawn, spawnSync } from "node:child_process";
+import { spawn as spawn2, spawnSync } from "node:child_process";
 import { mkdtempSync, readFileSync, rmSync, writeFileSync } from "node:fs";
 import path4 from "node:path";
 import os2 from "node:os";
@@ -82204,7 +82458,7 @@ class ExternalEditor {
     this.createTempFile();
     const promise2 = new Promise((resolve3, reject) => {
       try {
-        const editorProcess = spawn(this.editor.bin, this.editorArgs(), {
+        const editorProcess = spawn2(this.editor.bin, this.editorArgs(), {
           shell: false,
           stdio: "inherit"
         });
@@ -83544,51 +83798,15 @@ var init_admin = __esm(() => {
   };
 });
 
-// src/lib/proc.ts
-import { spawn as spawn2 } from "node:child_process";
-function run(file2, args = [], opts = {}) {
-  return new Promise((resolve3, reject) => {
-    const child3 = spawn2(file2, args, { cwd: opts.cwd, stdio: ["ignore", "pipe", "pipe"] });
-    let stdout = "";
-    let stderr = "";
-    child3.stdout?.setEncoding("utf8");
-    child3.stderr?.setEncoding("utf8");
-    child3.stdout?.on("data", (chunk) => {
-      stdout += chunk;
-    });
-    child3.stderr?.on("data", (chunk) => {
-      stderr += chunk;
-    });
-    child3.on("error", reject);
-    child3.on("close", (code) => resolve3({ code: code ?? -1, stdout, stderr }));
-  });
-}
-function runInherit(file2, args = [], opts = {}) {
-  return new Promise((resolve3, reject) => {
-    const child3 = spawn2(file2, args, { cwd: opts.cwd, stdio: "inherit" });
-    child3.on("error", reject);
-    child3.on("close", (code) => resolve3(code ?? -1));
-  });
-}
-function spawnHandle(file2, args = [], opts = {}) {
-  return spawn2(file2, args, {
-    cwd: opts.cwd,
-    env: opts.env,
-    detached: opts.detached,
-    stdio: opts.stdio ?? ["ignore", "inherit", "inherit"]
-  });
-}
-var init_proc = () => {};
-
 // src/lib/browser.ts
-import { mkdir as mkdir7, readFile as readFile8, writeFile as writeFile3 } from "node:fs/promises";
-import { join as join4 } from "node:path";
+import { mkdir as mkdir8, readFile as readFile9, writeFile as writeFile4 } from "node:fs/promises";
+import { join as join5 } from "node:path";
 function profileDirFor(host) {
-  return join4(BROWSER_DIR, host);
+  return join5(BROWSER_DIR, host);
 }
 async function saveSession(session) {
-  await mkdir7(paths3.home, { recursive: true });
-  await writeFile3(BROWSER_SESSION_PATH, `${JSON.stringify(session, null, 2)}
+  await mkdir8(paths3.home, { recursive: true });
+  await writeFile4(BROWSER_SESSION_PATH, `${JSON.stringify(session, null, 2)}
 `);
 }
 async function findAgentBrowser() {
@@ -83638,15 +83856,15 @@ var BROWSER_DIR, BROWSER_SESSION_PATH, AGENT_BROWSER_REPO = "vercel-labs/agent-b
 var init_browser = __esm(() => {
   init_state();
   init_proc();
-  BROWSER_DIR = join4(paths3.home, "browser");
-  BROWSER_SESSION_PATH = join4(paths3.home, "browser.json");
+  BROWSER_DIR = join5(paths3.home, "browser");
+  BROWSER_SESSION_PATH = join5(paths3.home, "browser.json");
   AUTH_EVAL = "fetch('/auth/me',{credentials:'include'})" + ".then(r=>r.json())" + ".then(j=>({authed:!!j.authenticated,email:j.user&&j.user.email}))" + ".catch(()=>({authed:false}))";
 });
 
 // src/lib/skills.ts
 import { existsSync, lstatSync, mkdirSync, readlinkSync, symlinkSync } from "node:fs";
 import { homedir as homedir2 } from "node:os";
-import { dirname as dirname7, join as join5 } from "node:path";
+import { dirname as dirname8, join as join6 } from "node:path";
 async function installSkills() {
   const { code, stdout, stderr } = await run("npx", [
     "skills",
@@ -83663,18 +83881,18 @@ function skillSearchDirs() {
   const dirs = [];
   let cur = process.cwd();
   for (;; ) {
-    dirs.push(join5(cur, ".claude", "skills"));
-    const parent = dirname7(cur);
+    dirs.push(join6(cur, ".claude", "skills"));
+    const parent = dirname8(cur);
     if (parent === cur)
       break;
     cur = parent;
   }
-  dirs.push(join5(homedir2(), ".claude", "skills"));
+  dirs.push(join6(homedir2(), ".claude", "skills"));
   return dirs;
 }
 function detectSkill(name) {
   for (const dir of skillSearchDirs()) {
-    const file2 = join5(dir, name, "SKILL.md");
+    const file2 = join6(dir, name, "SKILL.md");
     if (existsSync(file2))
       return { installed: true, location: file2 };
   }
@@ -83693,9 +83911,9 @@ function isSymlink(p) {
 function findAgentsSkillsRoot(fromDir) {
   let cur = fromDir;
   for (;; ) {
-    if (existsSync(join5(cur, ".agents", "skills")))
+    if (existsSync(join6(cur, ".agents", "skills")))
       return cur;
-    const parent = dirname7(cur);
+    const parent = dirname8(cur);
     if (parent === cur)
       return null;
     cur = parent;
@@ -83705,7 +83923,7 @@ function skillsBridgeStatus(fromDir = process.cwd()) {
   const root = findAgentsSkillsRoot(fromDir);
   if (!root)
     return { kind: "none" };
-  const link = join5(root, ".claude", "skills");
+  const link = join6(root, ".claude", "skills");
   if (isSymlink(link)) {
     try {
       if (readlinkSync(link) === BRIDGE_TARGET)
@@ -83721,7 +83939,7 @@ function ensureSkillsBridge(fromDir = process.cwd()) {
   const status = skillsBridgeStatus(fromDir);
   if (status.kind !== "unbridged")
     return status;
-  mkdirSync(dirname7(status.link), { recursive: true });
+  mkdirSync(dirname8(status.link), { recursive: true });
   symlinkSync(BRIDGE_TARGET, status.link);
   return { kind: "bridged", root: status.root };
 }
@@ -83730,7 +83948,7 @@ var init_skills = __esm(() => {
   init_browser();
   init_proc();
   SKILL_INSTALL_HINT = `npx skills add ${ASTRALE_CLI_SKILL_SOURCE} -g`;
-  BRIDGE_TARGET = join5("..", ".agents", "skills");
+  BRIDGE_TARGET = join6("..", ".agents", "skills");
 });
 
 // src/setup/steps/agent-browser.ts
@@ -83973,9 +84191,9 @@ var init_auth3 = __esm(() => {
 
 // src/setup/steps/domain.ts
 import { existsSync as existsSync2 } from "node:fs";
-import { join as join6 } from "node:path";
+import { join as join7 } from "node:path";
 function hasDomainProject() {
-  return existsSync2(join6(process.cwd(), "astrale.config.ts"));
+  return existsSync2(join7(process.cwd(), "astrale.config.ts"));
 }
 var FIX4 = "npx create-astrale-domain <name> --instance <slug>", domainStep;
 var init_domain7 = __esm(() => {
@@ -85940,14 +86158,14 @@ async function boundedResponse(response2, maximum, signal) {
     signal.removeEventListener("abort", abort);
     reader.releaseLock();
   }
-  return join7(chunks, total);
+  return join8(chunks, total);
 }
 function requireExactResponse(response2, expected, label) {
   if (response2.redirected || response2.url !== expected) {
     throw new ClientError(`${label} did not return the exact requested URL.`);
   }
 }
-function join7(parts2, length) {
+function join8(parts2, length) {
   if (parts2.length === 1)
     return new Uint8Array(parts2[0]);
   const output3 = new Uint8Array(length);
@@ -86751,73 +86969,161 @@ var init_session2 = __esm(() => {
   init_session();
 });
 
-// src/admin/binding.ts
-async function bindAdmin(session) {
-  const snapshot2 = await session.snapshot();
-  if (snapshot2.publication.origin !== ADMIN_ORIGIN || snapshot2.bundle.root.origin !== ADMIN_ORIGIN) {
-    throw new TypeError("Configured Admin target does not serve the Admin Domain.");
+// node_modules/.pnpm/@astrale-os+kernel-client@0.6.0-beta.4_typescript@6.0.3/node_modules/@astrale-os/kernel-client/dist/domain/callable.js
+async function invokeRemote(session, target2, callable, input, options) {
+  return dispatchCallable(session, target2, callable, undefined, input, options);
+}
+async function invokeRemoteMethod(session, target2, method, receiver, input, options) {
+  return dispatchCallable(session, target2, method, receiver, input, options);
+}
+function bindRemoteMethod(session, target2) {
+  return (method, receiver) => (input) => dispatchCallable(session, target2, method, Path.id(receiver.id), input);
+}
+function concreteRootCallables(domain3) {
+  const result = new Map;
+  for (const definition3 of domain3.$.definitions.values()) {
+    if (definition3.kind === "function") {
+      const callable = definition3;
+      result.set(callable.key, callable);
+      continue;
+    }
+    if (definition3.kind !== "class" && definition3.kind !== "interface" || definition3.family !== "node") {
+      continue;
+    }
+    for (const method of definition3.methods.values()) {
+      if (method.definition.inheritance !== "abstract") {
+        const callable = method;
+        result.set(callable.key, callable);
+      }
+    }
   }
-  const compatible = session;
-  const resolveInstallation = compatible.installation ?? compatible.installed;
-  if (resolveInstallation === undefined) {
-    throw new TypeError("Client Session cannot resolve an installed Admin Domain.");
-  }
-  const installation = await resolveInstallation.call(session, ADMIN_ORIGIN);
-  const domain3 = Domain.fromSchema(snapshot2.bundle.root);
-  const invoke = (callable, receiverOrInput, inputOrOptions, options) => {
-    const target2 = "on" in callable ? callable.on(Path.from(receiverOrInput)) : callable.path;
-    const reference3 = Object.freeze({
-      origin: ADMIN_ORIGIN,
-      revision: snapshot2.publication.schema.revision,
-      callable: callable.key,
-      target: target2,
-      outputMode: callable.definition.output.mode
-    });
-    return invokeCompatible(session, snapshot2, reference3, "on" in callable ? inputOrOptions : receiverOrInput, "on" in callable ? options : inputOrOptions);
-  };
-  return Object.freeze({
+  return result;
+}
+async function dispatchCallable(session, target2, callable, receiver, input, controls = {}) {
+  const bound = target2.callables.get(callable.key);
+  if (bound === undefined) {
+    throw new ClientError("Callable is not a concrete member of the bound Domain root.");
+  }
+  const path5 = receiver === undefined ? bound.path : bound.on(Path.from(receiver));
+  const result = await dispatchBound(session, call(path5, input), target2.bound, controls);
+  return requireOutput(bound, result);
+}
+function requireOutput(callable, result) {
+  const mode = callable.definition.output.mode;
+  switch (mode) {
+    case "value":
+      if (result.kind === "value")
+        return result.value;
+      break;
+    case "stream":
+      if (result.kind === "stream")
+        return result.stream;
+      break;
+    case "binary":
+      if (result.kind === "binary")
+        return result.value;
+      break;
+  }
+  return resultMismatch(mode, result);
+}
+function resultMismatch(expected, result) {
+  if (result.kind === "stream") {
+    result.stream.cancel(`Remote callable declared ${expected} output.`);
+  }
+  throw new ClientError(`Remote callable declared ${expected} output but returned ${result.kind}.`);
+}
+var init_callable4 = __esm(() => {
+  init_path4();
+  init_client3();
+  init_errors7();
+  init_session2();
+});
+
+// node_modules/.pnpm/@astrale-os+kernel-client@0.6.0-beta.4_typescript@6.0.3/node_modules/@astrale-os/kernel-client/dist/domain/node.js
+function bindNode(domain3, methodBinder, definitionOrValue, value2) {
+  return value2 === undefined ? domain3.$.wrap(definitionOrValue, methodBinder) : domain3.$.wrap(definitionOrValue, value2, methodBinder);
+}
+
+// node_modules/.pnpm/@astrale-os+kernel-client@0.6.0-beta.4_typescript@6.0.3/node_modules/@astrale-os/kernel-client/dist/domain/binding.js
+function bind(session, schemaOrInstalled, maybeInstalled) {
+  const installed = admitInstalled(maybeInstalled ?? schemaOrInstalled);
+  const published = installed.source.kind === "remote" ? installed.source.publication : undefined;
+  const root = maybeInstalled === undefined ? installed.bundle.root : schemaOrInstalled;
+  if (published !== undefined)
+    requireSchemaPublication(root, published);
+  if (root.origin !== installed.bundle.root.origin || exports_schema.revision(root) !== exports_schema.revision(installed.bundle.root)) {
+    throw new TypeError("Expected Domain schema does not match the installed schema Bundle.");
+  }
+  const domain3 = Domain.fromSchema(root);
+  const invocationTarget = Object.freeze({
+    callables: concreteRootCallables(domain3),
+    bound: Object.freeze({
+      schema: published === undefined ? Object.freeze({ target: installed.target }) : Object.freeze({ revision: exports_schema.revision(root) }),
+      ...published === undefined ? {} : { publication: exports_publication.reference(published) }
+    })
+  });
+  const methodBinder = bindRemoteMethod(session, invocationTarget);
+  const invoke = (callable, receiverOrInput, inputOrOptions, options) => ("on" in callable) ? invokeRemoteMethod(session, invocationTarget, callable, receiverOrInput, inputOrOptions, options) : invokeRemote(session, invocationTarget, callable, receiverOrInput, inputOrOptions);
+  const bind2 = (definitionOrValue, value2) => value2 === undefined ? bindNode(domain3, methodBinder, definitionOrValue) : bindNode(domain3, methodBinder, definitionOrValue, value2);
+  const binding6 = {
     ...domain3,
     $: Object.freeze({
       ...domain3.$,
-      installation,
-      publication: snapshot2.publication,
-      invoke
+      installed,
+      ...published === undefined ? {} : { publication: published },
+      invoke,
+      bind: bind2
     })
-  });
+  };
+  return Object.freeze(binding6);
 }
-async function invokeCompatible(session, snapshot2, reference3, input, options) {
-  const current = session;
-  if (current.invoke !== undefined)
-    return current.invoke(reference3, input, options);
-  const dispatchBound2 = dispatchBound;
-  if (dispatchBound2 === undefined) {
-    throw new TypeError("Client Session cannot invoke an exact Admin publication.");
+function admitInstalled(input) {
+  if (input === null || typeof input !== "object" || Array.isArray(input)) {
+    throw new TypeError("Installed Domain evidence is invalid.");
   }
-  const result = await dispatchBound2(session, call(reference3.target, input), {
-    schema: { revision: reference3.revision },
-    publication: {
-      origin: snapshot2.publication.origin,
-      identity: snapshot2.publication.identity,
-      revision: snapshot2.publication.schema.revision,
-      etag: snapshot2.publication.etag
-    }
-  }, options);
-  return requireOutput(reference3.outputMode, result);
+  if (input.state !== "ready" || input.readiness === null) {
+    throw new TypeError("Installed Domain is not ready.");
+  }
+  if (input.source.kind === "remote") {
+    const published = exports_publication.accept(input.source.publication);
+    const acceptedBundle = exports_publication.acceptBundle(published, input.bundle);
+    return Object.freeze({
+      ...input,
+      source: Object.freeze({ kind: "remote", publication: published }),
+      bundle: acceptedBundle
+    });
+  }
+  return input;
 }
-function requireOutput(expected, result) {
-  if (result.kind !== expected) {
-    if (result.kind === "stream")
-      result.stream.cancel(`Admin callable declared ${expected}.`);
-    throw new TypeError(`Admin callable declared ${expected} output but returned ${result.kind}.`);
+function requireSchemaPublication(domainSchema, published) {
+  if (domainSchema.origin !== published.origin || exports_schema.revision(domainSchema) !== published.schema.revision) {
+    throw new TypeError("Expected Domain schema does not match the target Publication revision.");
   }
-  return result.kind === "stream" ? result.stream : result.value;
 }
-var ADMIN_ORIGIN = "admin.astrale.ai";
 var init_binding3 = __esm(() => {
-  init_dist4();
-  init_session2();
-  init_domain6();
-  init_path5();
+  init_domain3();
+  init_v1();
+  init_dist2();
+  init_callable4();
+});
+
+// node_modules/.pnpm/@astrale-os+kernel-client@0.6.0-beta.4_typescript@6.0.3/node_modules/@astrale-os/kernel-client/dist/domain/index.js
+var init_domain8 = __esm(() => {
+  init_binding3();
+});
+
+// src/admin/binding.ts
+async function bindAdmin(session) {
+  const installed = await session.installed(ADMIN_ORIGIN);
+  const binding6 = bind(session, installed);
+  if (binding6.$.publication?.origin !== ADMIN_ORIGIN || binding6.$.origin !== ADMIN_ORIGIN) {
+    throw new TypeError("Configured Admin target does not serve the Admin Domain.");
+  }
+  return binding6;
+}
+var ADMIN_ORIGIN = "admin.astrale.ai";
+var init_binding4 = __esm(() => {
+  init_domain8();
 });
 
 // src/admin/graph/nodes.ts
@@ -87040,7 +87346,7 @@ var ADMIN_ORIGIN2 = "admin.astrale.ai", PAGE_SIZE = 256, MAXIMUM_INSTANCES = 1e4
 var init_client4 = __esm(() => {
   init_path5();
   init_query4();
-  init_binding3();
+  init_binding4();
   init_graph3();
   init_model6();
   MAXIMUM_PAGES2 = Math.ceil(MAXIMUM_INSTANCES / PAGE_SIZE) + 1;
@@ -89123,11 +89429,11 @@ var init_skills2 = __esm(() => {
 
 // src/setup/steps/skills-bridge.ts
 import { existsSync as existsSync3, readdirSync } from "node:fs";
-import { join as join8 } from "node:path";
+import { join as join9 } from "node:path";
 function countStaged(root) {
   try {
-    const dir = join8(root, ".agents", "skills");
-    return readdirSync(dir).filter((e) => existsSync3(join8(dir, e, "SKILL.md"))).length;
+    const dir = join9(root, ".agents", "skills");
+    return readdirSync(dir).filter((e) => existsSync3(join9(dir, e, "SKILL.md"))).length;
   } catch {
     return 0;
   }
@@ -89165,7 +89471,7 @@ var init_skills_bridge = __esm(() => {
       }
       const after = ensureSkillsBridge();
       if (after.kind === "bridged") {
-        log.success(`Workspace skills bridged — ${join8(after.root, ".agents/skills")} → .claude/skills`);
+        log.success(`Workspace skills bridged — ${join9(after.root, ".agents/skills")} → .claude/skills`);
         return "fixed";
       }
       log.warn("Could not create the skills bridge — create it manually: ln -s ../.agents/skills .claude/skills");
@@ -89627,18 +89933,18 @@ Examples:
 
 // src/lib/sdk-deps.ts
 import { existsSync as existsSync4 } from "node:fs";
-import { join as join9 } from "node:path";
+import { join as join10 } from "node:path";
 function inDomainProject(cwd = process.cwd()) {
-  return existsSync4(join9(cwd, "astrale.config.ts"));
+  return existsSync4(join10(cwd, "astrale.config.ts"));
 }
 function foreignPackageManager(cwd = process.cwd()) {
-  if (existsSync4(join9(cwd, "pnpm-lock.yaml")))
+  if (existsSync4(join10(cwd, "pnpm-lock.yaml")))
     return null;
-  if (existsSync4(join9(cwd, "package-lock.json")))
+  if (existsSync4(join10(cwd, "package-lock.json")))
     return "npm";
-  if (existsSync4(join9(cwd, "yarn.lock")))
+  if (existsSync4(join10(cwd, "yarn.lock")))
     return "yarn";
-  if (existsSync4(join9(cwd, "bun.lockb")) || existsSync4(join9(cwd, "bun.lock")))
+  if (existsSync4(join10(cwd, "bun.lockb")) || existsSync4(join10(cwd, "bun.lock")))
     return "bun";
   return null;
 }
@@ -89683,211 +89989,6 @@ var init_sdk_deps = __esm(() => {
   init_proc();
 });
 
-// src/lib/update.ts
-import { createHash } from "node:crypto";
-import { chmod as chmod2, copyFile, mkdir as mkdir8, mkdtemp, readFile as readFile9, rename as rename2, rm, writeFile as writeFile4 } from "node:fs/promises";
-import { tmpdir } from "node:os";
-import { dirname as dirname8, join as join10 } from "node:path";
-function detectPlatform() {
-  const os3 = process.platform;
-  const arch = process.arch;
-  if (os3 !== "darwin" && os3 !== "linux") {
-    throw new AstraleError("UNSUPPORTED_PLATFORM", `Unsupported OS "${os3}" — Astrale update supports macOS and Linux.`);
-  }
-  if (arch !== "arm64" && arch !== "x64") {
-    throw new AstraleError("UNSUPPORTED_PLATFORM", `Unsupported CPU architecture "${arch}" — Astrale update supports arm64 and x64.`);
-  }
-  return { os: os3, arch };
-}
-function platformKey(platform) {
-  return `${platform.os}-${platform.arch}`;
-}
-function isStandaloneBinary() {
-  return Boolean(process.versions.bun);
-}
-async function readInstallMetadata(path5 = INSTALL_PATH) {
-  let raw2;
-  try {
-    raw2 = await readFile9(path5, "utf8");
-  } catch {
-    throw isStandaloneBinary() ? new AstraleError("UPDATE_NOT_SCRIPT_INSTALLED", "Astrale was not installed by the official install script.", "Reinstall with: curl -fsSL https://raw.githubusercontent.com/astrale-os/cli/main/install.sh | sh") : new AstraleError("UPDATE_PACKAGE_MANAGED", "This Astrale build is managed by your package manager.", "Update with: npm install -g @astrale-os/cli@latest  (or pnpm/bun)");
-  }
-  const parsed = InstallMetadataSchema.safeParse(JSON.parse(raw2));
-  if (!parsed.success) {
-    throw new AstraleError("UPDATE_BAD_INSTALL_METADATA", `Invalid install metadata at ${path5}.`, "Reinstall with: curl -fsSL https://raw.githubusercontent.com/astrale-os/cli/main/install.sh | sh");
-  }
-  return parsed.data;
-}
-async function writeInstallMetadata(meta3, path5 = INSTALL_PATH) {
-  await mkdir8(dirname8(path5), { recursive: true });
-  await writeFile4(path5, JSON.stringify(meta3, null, 2) + `
-`);
-}
-function releaseBase(meta3, req) {
-  if (process.env.ASTRALE_UPDATE_BASE)
-    return process.env.ASTRALE_UPDATE_BASE.replace(/\/+$/, "");
-  const repo = meta3.repo || DEFAULT_REPO;
-  if (req.version) {
-    const version2 = req.version.replace(/^cli\/v/, "").replace(/^v/, "");
-    return `https://github.com/${repo}/releases/download/cli/v${version2}`;
-  }
-  return `https://github.com/${repo}/releases/download/${req.channel ?? meta3.channel ?? DEFAULT_UPDATE_CHANNEL}`;
-}
-async function fetchManifest(base2) {
-  const raw2 = await readUrlText(`${base2}/manifest.json`);
-  return UpdateManifestSchema.parse(JSON.parse(raw2));
-}
-function shouldUpdate(currentVersion, manifestVersion) {
-  return currentVersion !== manifestVersion;
-}
-async function updateAstrale(req) {
-  const meta3 = await readInstallMetadata(req.installPath);
-  const currentVersion = meta3.version ?? req.currentVersion;
-  const channel = req.channel ?? meta3.channel ?? DEFAULT_UPDATE_CHANNEL;
-  const platform = req.platform ?? detectPlatform();
-  const key = platformKey(platform);
-  const base2 = releaseBase(meta3, { channel, version: req.version });
-  const manifest = await fetchManifest(base2);
-  const asset = manifest.assets[key];
-  if (!asset) {
-    throw new AstraleError("UPDATE_ASSET_NOT_FOUND", `No Astrale CLI release asset for ${key}.`, `Available platforms: ${Object.keys(manifest.assets).join(", ")}`);
-  }
-  if (!shouldUpdate(currentVersion, manifest.version)) {
-    return {
-      status: "up-to-date",
-      currentVersion,
-      latestVersion: manifest.version,
-      channel: manifest.channel
-    };
-  }
-  if (req.check) {
-    return {
-      status: "available",
-      currentVersion,
-      latestVersion: manifest.version,
-      channel: manifest.channel
-    };
-  }
-  const tmp = await mkdtemp(join10(tmpdir(), "astrale-update-"));
-  try {
-    const archive = join10(tmp, asset.name);
-    await downloadToFile(`${base2}/${asset.name}`, archive);
-    const manifestChecksum = "sha256" in asset ? asset.sha256 : undefined;
-    const expected = manifestChecksum ?? await fetchChecksum(base2, asset.name);
-    const actual = await sha256File(archive);
-    if (actual !== expected.toLowerCase()) {
-      throw new AstraleError("UPDATE_CHECKSUM_MISMATCH", `Checksum mismatch for ${asset.name}.`, `Expected ${expected}; got ${actual}.`);
-    }
-    await extractTarGz(archive, tmp);
-    const nextBin = join10(tmp, "astrale");
-    await chmod2(nextBin, 493);
-    await smokeVersion(nextBin, manifest.binaryVersion ?? manifest.version);
-    const previous = `${meta3.bin}.previous`;
-    const staged = `${meta3.bin}.next`;
-    await copyFile(meta3.bin, previous).catch(() => {
-      return;
-    });
-    await copyFile(nextBin, staged);
-    await chmod2(staged, 493);
-    await rename2(staged, meta3.bin);
-    await writeInstallMetadata({
-      ...meta3,
-      channel: manifest.channel,
-      version: manifest.version,
-      installedAt: new Date().toISOString()
-    }, req.installPath);
-    return {
-      status: "updated",
-      previousVersion: currentVersion,
-      currentVersion: manifest.version,
-      channel: manifest.channel,
-      bin: meta3.bin
-    };
-  } finally {
-    await rm(tmp, { recursive: true, force: true });
-  }
-}
-async function readUrlText(url3) {
-  if (url3.startsWith("file://")) {
-    return readFile9(new URL(url3), "utf8");
-  }
-  const res = await fetch(url3);
-  if (!res.ok)
-    throw new Error(`GET ${url3} failed: HTTP ${res.status}`);
-  return res.text();
-}
-async function downloadToFile(url3, path5) {
-  if (url3.startsWith("file://")) {
-    await copyFile(new URL(url3), path5);
-    return;
-  }
-  const res = await fetch(url3);
-  if (!res.ok)
-    throw new Error(`GET ${url3} failed: HTTP ${res.status}`);
-  const bytes = new Uint8Array(await res.arrayBuffer());
-  await writeFile4(path5, bytes);
-}
-async function fetchChecksum(base2, assetName) {
-  const raw2 = await readUrlText(`${base2}/sha256sums.txt`);
-  for (const line of raw2.split(/\r?\n/)) {
-    const [sha, file2] = line.trim().split(/\s+/, 2);
-    if (!sha || !file2)
-      continue;
-    if (file2.replace(/^\*/, "") === assetName && /^[a-fA-F0-9]{64}$/.test(sha))
-      return sha;
-  }
-  throw new AstraleError("UPDATE_CHECKSUM_NOT_FOUND", `Checksum entry not found for ${assetName}.`, `Release base: ${base2}`);
-}
-async function sha256File(path5) {
-  const hash2 = createHash("sha256");
-  hash2.update(await readFile9(path5));
-  return hash2.digest("hex");
-}
-async function extractTarGz(archive, cwd) {
-  const { code, stderr } = await run("tar", ["-xzf", archive, "-C", cwd]);
-  if (code !== 0) {
-    throw new Error(`Could not extract update archive: ${stderr.trim()}`);
-  }
-}
-async function smokeVersion(bin, expectedVersion) {
-  const { code, stdout, stderr } = await run(bin, ["--version"]);
-  if (code !== 0)
-    throw new Error(`Updated binary failed --version: ${stderr.trim()}`);
-  const actual = stdout.trim();
-  if (actual !== expectedVersion) {
-    throw new Error(`Updated binary reported version ${actual}, expected ${expectedVersion}`);
-  }
-}
-var DEFAULT_REPO = "astrale-os/cli", DEFAULT_UPDATE_CHANNEL = "beta", InstallMetadataSchema, ManifestAssetSchema, UpdateManifestSchema;
-var init_update = __esm(() => {
-  init_zod2();
-  init_errors2();
-  init_state();
-  init_proc();
-  InstallMetadataSchema = exports_external2.object({
-    method: exports_external2.literal("script"),
-    channel: exports_external2.string().min(1).default(DEFAULT_UPDATE_CHANNEL),
-    version: exports_external2.string().min(1).optional(),
-    repo: exports_external2.string().min(1).default(DEFAULT_REPO),
-    bin: exports_external2.string().min(1),
-    installedAt: exports_external2.string().optional()
-  });
-  ManifestAssetSchema = exports_external2.object({
-    name: exports_external2.string().min(1),
-    sha256: exports_external2.string().regex(/^[a-fA-F0-9]{64}$/).optional()
-  });
-  UpdateManifestSchema = exports_external2.object({
-    version: exports_external2.string().min(1),
-    binaryVersion: exports_external2.string().min(1).optional(),
-    channel: exports_external2.string().min(1),
-    repo: exports_external2.string().min(1).optional(),
-    assets: exports_external2.record(exports_external2.string(), exports_external2.union([
-      ManifestAssetSchema,
-      exports_external2.string().min(1).transform((name) => ({ name }))
-    ]))
-  });
-});
-
 // src/commands/update.ts
 var exports_update = {};
 __export(exports_update, {
@@ -93473,7 +93574,7 @@ var ADMIN_ORIGIN3 = "admin.astrale.ai", PAGE_SIZE2 = 256, MAXIMUM_DOMAINS = 1e4,
 var init_client5 = __esm(() => {
   init_path5();
   init_query4();
-  init_binding3();
+  init_binding4();
   init_graph3();
   init_model7();
   MAXIMUM_PAGES3 = Math.ceil(MAXIMUM_DOMAINS / PAGE_SIZE2) + 1;