@construct-space/cli 1.9.5 → 1.9.6

package/dist/index.js

@@ -2790,8 +2790,8 @@ var require_lib = __commonJS((exports, module) => {
 });
 
 // src/lib/appdir.ts
-import { existsSync as existsSync8, readFileSync as readFileSync6 } from "fs";
-import { join as join10 } from "path";
+import { existsSync as existsSync9, readFileSync as readFileSync6 } from "fs";
+import { join as join11 } from "path";
 import { homedir } from "os";
 import { platform } from "process";
 function dataDir() {
@@ -2800,32 +2800,32 @@ function dataDir() {
   const home = homedir();
   switch (platform) {
     case "darwin":
-      return join10(home, "Library", "Application Support", "Construct");
+      return join11(home, "Library", "Application Support", "Construct");
     case "win32": {
-      const appData = process.env.APPDATA || join10(home, "AppData", "Roaming");
-      return join10(appData, "Construct");
+      const appData = process.env.APPDATA || join11(home, "AppData", "Roaming");
+      return join11(appData, "Construct");
     }
     default: {
-      const xdg = process.env.XDG_DATA_HOME || join10(home, ".local", "share");
-      return join10(xdg, "construct");
+      const xdg = process.env.XDG_DATA_HOME || join11(home, ".local", "share");
+      return join11(xdg, "construct");
     }
   }
 }
 function profilesDir() {
-  return join10(dataDir(), "profiles");
+  return join11(dataDir(), "profiles");
 }
 function activeProfileId() {
   try {
-    const credsPath = join10(dataDir(), "credentials.json");
-    if (existsSync8(credsPath)) {
+    const credsPath = join11(dataDir(), "credentials.json");
+    if (existsSync9(credsPath)) {
       const c = JSON.parse(readFileSync6(credsPath, "utf-8"));
       if (c.profileId)
         return c.profileId;
     }
   } catch {}
   try {
-    const regPath = join10(dataDir(), "profiles.json");
-    if (existsSync8(regPath)) {
+    const regPath = join11(dataDir(), "profiles.json");
+    if (existsSync9(regPath)) {
       const r = JSON.parse(readFileSync6(regPath, "utf-8"));
       if (r.active_profile)
         return r.active_profile;
@@ -2836,29 +2836,29 @@ function activeProfileId() {
 function spacesDir() {
   const profileId = activeProfileId();
   if (profileId)
-    return join10(profilesDir(), profileId, "spaces");
-  return join10(dataDir(), "spaces");
+    return join11(profilesDir(), profileId, "spaces");
+  return join11(dataDir(), "spaces");
 }
 function spaceDir(spaceId) {
-  return join10(spacesDir(), spaceId);
+  return join11(spacesDir(), `${spaceId}.space`);
 }
 var init_appdir = () => {};
 
 // src/lib/auth.ts
-import { readFileSync as readFileSync7, writeFileSync as writeFileSync5, mkdirSync as mkdirSync4, unlinkSync, existsSync as existsSync10, readdirSync as readdirSync5, statSync as statSync3 } from "fs";
-import { join as join12, dirname as dirname4 } from "path";
+import { readFileSync as readFileSync7, writeFileSync as writeFileSync5, mkdirSync as mkdirSync6, unlinkSync, existsSync as existsSync11, readdirSync as readdirSync5, statSync as statSync2 } from "fs";
+import { join as join13, dirname as dirname5 } from "path";
 function listDesktopProfiles() {
   const dir = profilesDir();
-  if (!existsSync10(dir))
+  if (!existsSync11(dir))
     return [];
   const results = [];
   for (const entry of readdirSync5(dir)) {
-    const full = join12(dir, entry);
+    const full = join13(dir, entry);
     try {
-      if (!statSync3(full).isDirectory())
+      if (!statSync2(full).isDirectory())
         continue;
-      const authPath = join12(full, "auth.json");
-      if (!existsSync10(authPath))
+      const authPath = join13(full, "auth.json");
+      if (!existsSync11(authPath))
         continue;
       const data = JSON.parse(readFileSync7(authPath, "utf-8"));
       if (!data.token)
@@ -2877,14 +2877,14 @@ function listDesktopProfiles() {
   return results;
 }
 function legacyCredentialsPath() {
-  return join12(dataDir(), LEGACY_CREDENTIALS_FILE);
+  return join13(dataDir(), LEGACY_CREDENTIALS_FILE);
 }
 function registryPath() {
-  return join12(dataDir(), PROFILES_REGISTRY);
+  return join13(dataDir(), PROFILES_REGISTRY);
 }
 function readRegistry() {
   const path = registryPath();
-  if (!existsSync10(path))
+  if (!existsSync11(path))
     return {};
   try {
     return JSON.parse(readFileSync7(path, "utf-8"));
@@ -2894,7 +2894,7 @@ function readRegistry() {
 }
 function writeRegistry(reg) {
   const path = registryPath();
-  mkdirSync4(dirname4(path), { recursive: true });
+  mkdirSync6(dirname5(path), { recursive: true });
   writeFileSync5(path, JSON.stringify({ version: 1, ...reg }, null, 2));
 }
 function store(creds) {
@@ -2902,10 +2902,10 @@ function store(creds) {
   if (!profileId) {
     throw new Error("cannot store credentials without a profile id (user.id or profileId)");
   }
-  const profilePath = join12(profilesDir(), profileId, "auth.json");
-  mkdirSync4(dirname4(profilePath), { recursive: true });
+  const profilePath = join13(profilesDir(), profileId, "auth.json");
+  mkdirSync6(dirname5(profilePath), { recursive: true });
   let existing = {};
-  if (existsSync10(profilePath)) {
+  if (existsSync11(profilePath)) {
     try {
       existing = JSON.parse(readFileSync7(profilePath, "utf-8"));
     } catch {}
@@ -2945,7 +2945,7 @@ function store(creds) {
 }
 function migrateLegacyCredentials() {
   const legacy = legacyCredentialsPath();
-  if (!existsSync10(legacy))
+  if (!existsSync11(legacy))
     return;
   try {
     const data = JSON.parse(readFileSync7(legacy, "utf-8"));
@@ -2954,8 +2954,8 @@ function migrateLegacyCredentials() {
     const pid = data.profileId || data.user?.id;
     if (!pid)
       return;
-    const profilePath = join12(profilesDir(), pid, "auth.json");
-    if (existsSync10(profilePath))
+    const profilePath = join13(profilesDir(), pid, "auth.json");
+    if (existsSync11(profilePath))
       return;
     store({ ...data, profileId: pid });
   } catch {}
@@ -2969,15 +2969,15 @@ function load2() {
 }
 function loadFromActiveProfile() {
   try {
-    const regPath = join12(dataDir(), "profiles.json");
-    if (!existsSync10(regPath))
+    const regPath = join13(dataDir(), "profiles.json");
+    if (!existsSync11(regPath))
       return null;
     const reg = JSON.parse(readFileSync7(regPath, "utf-8"));
     const activeId = reg.active_profile;
     if (!activeId)
       return null;
-    const authPath = join12(profilesDir(), activeId, "auth.json");
-    if (!existsSync10(authPath))
+    const authPath = join13(profilesDir(), activeId, "auth.json");
+    if (!existsSync11(authPath))
       return null;
     const a = JSON.parse(readFileSync7(authPath, "utf-8"));
     if (!a.token)
@@ -3014,8 +3014,8 @@ function clear() {
   const reg = readRegistry();
   const activeId = reg.active_profile;
   if (activeId) {
-    const profilePath = join12(profilesDir(), activeId, "auth.json");
-    if (existsSync10(profilePath)) {
+    const profilePath = join13(profilesDir(), activeId, "auth.json");
+    if (existsSync11(profilePath)) {
       try {
         const data = JSON.parse(readFileSync7(profilePath, "utf-8"));
         data.authenticated = false;
@@ -3025,7 +3025,7 @@ function clear() {
     }
   }
   const legacy = legacyCredentialsPath();
-  if (existsSync10(legacy))
+  if (existsSync11(legacy))
     unlinkSync(legacy);
 }
 var LEGACY_CREDENTIALS_FILE = "credentials.json", PROFILES_REGISTRY = "profiles.json", DEFAULT_PORTAL = "https://my.construct.space/api/developer";
@@ -5453,6 +5453,8 @@ async function scaffold(nameArg, options) {
     join2(name, "scripts"),
     join2(name, "references"),
     join2(name, "assets"),
+    join2(name, "tools"),
+    join2(name, "lib"),
     join2(name, "agent", "hooks"),
     join2(name, "agent", "tools"),
     join2(name, "widgets", "summary")
@@ -5516,9 +5518,9 @@ async function scaffold(nameArg, options) {
 
 // src/commands/build.ts
 init_source();
-import { cpSync, existsSync as existsSync6, readFileSync as readFileSync4, readdirSync as readdirSync3, renameSync, statSync as statSync2 } from "fs";
-import { join as join6 } from "path";
-import { createHash } from "crypto";
+import { existsSync as existsSync7, readFileSync as readFileSync4, readdirSync as readdirSync3, renameSync, rmSync as rmSync2 } from "fs";
+import { join as join7 } from "path";
+import { createHash as createHash2 } from "crypto";
 
 // node_modules/ora/index.js
 init_source();
@@ -8154,6 +8156,7 @@ function ora(options) {
 import { readFileSync as readFileSync2, writeFileSync as writeFileSync2, existsSync as existsSync3 } from "fs";
 import { join as join3 } from "path";
 var MANIFEST_FILE = "space.manifest.json";
+var HOST_API_VERSION = "0.6.0";
 var idRegex = /^[a-z][a-z0-9-]*$/;
 var versionRegex = /^\d+\.\d+\.\d+/;
 function validate2(m) {
@@ -8362,74 +8365,216 @@ function writeEntry(root, m) {
   writeFileSync3(join4(srcDir, "entry.ts"), generate(root, m));
 }
 
-// src/lib/agent.ts
-import { readFileSync as readFileSync3, writeFileSync as writeFileSync4, readdirSync as readdirSync2, existsSync as existsSync5 } from "fs";
-import { join as join5, extname as extname2, basename as basename2 } from "path";
-var AGENT_KEY = "construct-agent-obfuscate-v1";
-function encode(content) {
-  const key = Buffer.from(AGENT_KEY);
-  const data = Buffer.from(content);
-  const xored = Buffer.alloc(data.length);
-  for (let i = 0;i < data.length; i++) {
-    xored[i] = data[i] ^ key[i % key.length];
-  }
-  return xored.toString("base64");
-}
-function readMdFiles(dir) {
-  const result = {};
-  if (!existsSync5(dir))
-    return result;
-  for (const f of readdirSync2(dir)) {
-    if (extname2(f) !== ".md")
+// src/lib/spaceBundle.ts
+import { createHash } from "crypto";
+import { cpSync, existsSync as existsSync5, lstatSync, mkdirSync as mkdirSync3, readFileSync as readFileSync3, readdirSync as readdirSync2, rmSync, writeFileSync as writeFileSync4 } from "fs";
+import { basename as basename2, dirname as dirname2, join as join5, relative as relative2 } from "path";
+var BUNDLE_DIRS = ["agent", "scripts", "references", "assets", "icons", "media", "public", "tools", "lib"];
+var BUNDLE_FILES = ["SKILL.md"];
+function stageSpaceResources(root, distDir) {
+  const copied = [];
+  for (const name of BUNDLE_DIRS) {
+    rmSync(join5(distDir, name), { recursive: true, force: true });
+    const src = join5(root, name);
+    if (!existsSync5(src) || !lstatSync(src).isDirectory())
       continue;
-    result[basename2(f, ".md")] = readFileSync3(join5(dir, f), "utf-8");
+    cpSync(src, join5(distDir, name), { recursive: true, verbatimSymlinks: true });
+    copied.push(name);
   }
-  return result;
+  for (const name of BUNDLE_FILES) {
+    rmSync(join5(distDir, name), { recursive: true, force: true });
+    const src = join5(root, name);
+    if (!existsSync5(src) || !lstatSync(src).isFile())
+      continue;
+    cpSync(src, join5(distDir, name), { verbatimSymlinks: true });
+    copied.push(name);
+  }
+  return copied;
 }
-function readJsonFiles(dir) {
-  const result = {};
-  if (!existsSync5(dir))
-    return result;
-  for (const f of readdirSync2(dir)) {
-    if (extname2(f) !== ".json")
+function slashPath(path) {
+  return path.replace(/\\/g, "/");
+}
+function copyFileIntoBundle(src, dst) {
+  mkdirSync3(dirname2(dst), { recursive: true });
+  cpSync(src, dst, { verbatimSymlinks: true });
+}
+function collectFiles(root) {
+  const files = [];
+  function walk(dir) {
+    for (const name of readdirSync2(dir).sort()) {
+      const path = join5(dir, name);
+      const stat = lstatSync(path);
+      if (stat.isSymbolicLink())
+        continue;
+      if (stat.isDirectory()) {
+        walk(path);
+      } else if (stat.isFile()) {
+        files.push(slashPath(relative2(root, path)));
+      }
+    }
+  }
+  walk(root);
+  return files;
+}
+function sha256(path) {
+  return createHash("sha256").update(readFileSync3(path)).digest("hex");
+}
+function writeChecksums(spaceDir, spaceId) {
+  const files = collectFiles(spaceDir).filter((file) => file !== "checksums.json");
+  const checksums = {};
+  for (const file of files) {
+    checksums[file] = sha256(join5(spaceDir, file));
+  }
+  writeFileSync4(join5(spaceDir, "checksums.json"), JSON.stringify({
+    format: "construct.space/v1",
+    id: spaceId,
+    files: checksums
+  }, null, 2) + `
+`);
+  return collectFiles(spaceDir);
+}
+function createSpaceBundle(options) {
+  const spaceDir = join5(options.distDir, `${options.spaceId}.space`);
+  const appName = basename2(options.appBundlePath);
+  const cssName = options.cssPath ? basename2(options.cssPath) : "";
+  rmSync(spaceDir, { recursive: true, force: true });
+  mkdirSync3(spaceDir, { recursive: true });
+  copyFileIntoBundle(join5(options.distDir, "manifest.json"), join5(spaceDir, "manifest.json"));
+  copyFileIntoBundle(options.appBundlePath, join5(spaceDir, "app.iife.js"));
+  const hasStyle = Boolean(options.cssPath && existsSync5(options.cssPath));
+  if (hasStyle && options.cssPath) {
+    copyFileIntoBundle(options.cssPath, join5(spaceDir, "style.css"));
+  }
+  for (const entry of readdirSync2(options.distDir)) {
+    if (entry === `${options.spaceId}.space`)
       continue;
-    result[basename2(f, ".json")] = readFileSync3(join5(dir, f), "utf-8");
+    if (entry.endsWith(".space"))
+      continue;
+    if (entry === "manifest.json")
+      continue;
+    if (entry === appName || entry === cssName)
+      continue;
+    if (entry.endsWith(".iife.js") || entry.endsWith(".css"))
+      continue;
+    cpSync(join5(options.distDir, entry), join5(spaceDir, entry), {
+      recursive: true,
+      verbatimSymlinks: true
+    });
   }
-  return result;
+  return {
+    dir: spaceDir,
+    hasStyle,
+    files: writeChecksums(spaceDir, options.spaceId)
+  };
 }
-function bundleAgentDir(srcDir, distDir) {
-  const bundle = {
-    config: "",
-    tools: readMdFiles(join5(srcDir, "tools")),
-    skills: readMdFiles(join5(srcDir, "skills")),
-    hooks: readJsonFiles(join5(srcDir, "hooks"))
+
+// src/lib/spaceTools.ts
+import { existsSync as existsSync6, mkdirSync as mkdirSync4 } from "fs";
+import { join as join6 } from "path";
+import { arch as nodeArch, platform as nodePlatform } from "process";
+import { spawnSync } from "child_process";
+var SPACE_TOOL_TARGETS = [
+  "darwin-arm64",
+  "darwin-x64",
+  "linux-arm64",
+  "linux-x64",
+  "windows-arm64",
+  "windows-x64"
+];
+var GO_TARGETS = {
+  "darwin-arm64": { goos: "darwin", goarch: "arm64", ext: "" },
+  "darwin-x64": { goos: "darwin", goarch: "amd64", ext: "" },
+  "linux-arm64": { goos: "linux", goarch: "arm64", ext: "" },
+  "linux-x64": { goos: "linux", goarch: "amd64", ext: "" },
+  "windows-arm64": { goos: "windows", goarch: "arm64", ext: ".exe" },
+  "windows-x64": { goos: "windows", goarch: "amd64", ext: ".exe" }
+};
+function isSpaceToolTarget(value) {
+  return SPACE_TOOL_TARGETS.includes(value);
+}
+function currentSpaceToolTarget(platform = nodePlatform, arch = nodeArch) {
+  if (platform === "darwin" && arch === "arm64")
+    return "darwin-arm64";
+  if (platform === "darwin" && arch === "x64")
+    return "darwin-x64";
+  if (platform === "linux" && arch === "arm64")
+    return "linux-arm64";
+  if (platform === "linux" && arch === "x64")
+    return "linux-x64";
+  if (platform === "win32" && arch === "arm64")
+    return "windows-arm64";
+  if (platform === "win32" && arch === "x64")
+    return "windows-x64";
+  return null;
+}
+function parseSpaceToolTargets(value = process.env.CONSTRUCT_TOOL_TARGETS) {
+  const raw = value?.trim();
+  if (!raw) {
+    const current = currentSpaceToolTarget();
+    if (!current)
+      throw new Error(`Unsupported tool build platform: ${nodePlatform}-${nodeArch}`);
+    return [current];
+  }
+  if (raw === "all")
+    return [...SPACE_TOOL_TARGETS];
+  const targets = raw.split(/[,\s]+/).filter(Boolean);
+  const invalid = targets.filter((target) => !isSpaceToolTarget(target));
+  if (invalid.length > 0) {
+    throw new Error(`Invalid CONSTRUCT_TOOL_TARGETS value: ${invalid.join(", ")}. ` + `Expected one or more of: ${SPACE_TOOL_TARGETS.join(", ")}, or "all".`);
+  }
+  return Array.from(new Set(targets));
+}
+function defaultRunner(invocation) {
+  const result = spawnSync("go", invocation.args, {
+    cwd: invocation.root,
+    env: invocation.env,
+    encoding: "utf-8"
+  });
+  return {
+    status: result.status,
+    stdout: result.stdout || "",
+    stderr: result.stderr || "",
+    error: result.error
   };
-  for (const name of ["config.md", "agent.md"]) {
-    const path = join5(srcDir, name);
-    if (existsSync5(path)) {
-      bundle.config = readFileSync3(path, "utf-8");
-      break;
+}
+function buildSpaceTools(root, distDir, spaceId, options = {}) {
+  const sourcePath = join6(root, "tools.go");
+  if (!existsSync6(sourcePath))
+    return [];
+  const built = [];
+  const targets = options.targets ?? parseSpaceToolTargets(options.env?.CONSTRUCT_TOOL_TARGETS);
+  const runner = options.runner ?? defaultRunner;
+  for (const target of targets) {
+    const goTarget = GO_TARGETS[target];
+    const outputDir = join6(distDir, "tools", target);
+    const outputName = `${spaceId}-tools${goTarget.ext}`;
+    const outputPath = join6(outputDir, outputName);
+    mkdirSync4(outputDir, { recursive: true });
+    const env2 = {
+      ...process.env,
+      ...options.env,
+      GOOS: goTarget.goos,
+      GOARCH: goTarget.goarch
+    };
+    if (!env2.CGO_ENABLED)
+      env2.CGO_ENABLED = "0";
+    const args = ["build", "-trimpath", "-o", outputPath, "./tools.go"];
+    const result = runner({ root, target, outputPath, args, env: env2 });
+    if (result.error) {
+      throw new Error(`Failed to build tools.go for ${target}: ${result.error.message}`);
     }
+    if (result.status !== 0) {
+      const details = [result.stderr, result.stdout].filter(Boolean).join(`
+`).trim();
+      throw new Error(`Failed to build tools.go for ${target}${details ? `:
+${details}` : ""}`);
+    }
+    built.push(`tools/${target}/${outputName}`);
   }
-  if (!bundle.config)
-    return;
-  const encoded = encode(JSON.stringify(bundle));
-  writeFileSync4(join5(distDir, "config.agent"), encoded);
+  return built;
 }
 
 // src/commands/build.ts
-var ASSET_DIRS = ["icons", "assets", "media", "public", "bin"];
-function copyAssetDirs(root, distDir) {
-  const copied = [];
-  for (const name of ASSET_DIRS) {
-    const src = join6(root, name);
-    if (!existsSync6(src) || !statSync2(src).isDirectory())
-      continue;
-    cpSync(src, join6(distDir, name), { recursive: true, verbatimSymlinks: true });
-    copied.push(name);
-  }
-  return copied;
-}
 function stripTsComments(source) {
   let out = "";
   let i = 0;
@@ -8629,41 +8774,52 @@ async function build(options) {
     process.exit(1);
   }
   runHook(m.hooks, "postBuild", root);
-  const agentDir = join6(root, "agent");
-  if (existsSync6(agentDir) && statSync2(agentDir).isDirectory()) {
-    const distDir2 = join6(root, "dist");
-    bundleAgentDir(agentDir, distDir2);
-    bundleAgentDir(agentDir, root);
+  const copiedResources = stageSpaceResources(root, join7(root, "dist"));
+  if (copiedResources.length > 0) {
+    console.log(source_default.blue(`  Resources: ${copiedResources.join(", ")}`));
   }
-  const copiedAssetDirs = copyAssetDirs(root, join6(root, "dist"));
-  if (copiedAssetDirs.length > 0) {
-    console.log(source_default.blue(`  Assets: ${copiedAssetDirs.join(", ")}`));
+  try {
+    const builtTools = buildSpaceTools(root, join7(root, "dist"), m.id);
+    if (builtTools.length > 0) {
+      console.log(source_default.blue(`  Tools: ${builtTools.join(", ")}`));
+    }
+  } catch (err) {
+    console.error(source_default.red(err?.message || String(err)));
+    process.exit(1);
   }
-  const distDir = join6(root, "dist");
+  const distDir = join7(root, "dist");
   const expectedBundle = `space-${m.id}.iife.js`;
-  const bundlePath = join6(distDir, expectedBundle);
-  if (!existsSync6(bundlePath)) {
+  const bundlePath = join7(distDir, expectedBundle);
+  if (!existsSync7(bundlePath)) {
     const matches = readdirSync3(distDir).filter((f) => f.startsWith("space-") && f.endsWith(".iife.js"));
     if (matches.length === 1) {
-      renameSync(join6(distDir, matches[0]), bundlePath);
-      const oldCSS = join6(distDir, matches[0].replace(".iife.js", ".css"));
-      const newCSS = join6(distDir, `space-${m.id}.css`);
-      if (existsSync6(oldCSS))
+      renameSync(join7(distDir, matches[0]), bundlePath);
+      const oldCSS = join7(distDir, matches[0].replace(".iife.js", ".css"));
+      const newCSS = join7(distDir, `space-${m.id}.css`);
+      if (existsSync7(oldCSS))
         renameSync(oldCSS, newCSS);
     }
   }
-  const expectedCSS = join6(distDir, `space-${m.id}.css`);
-  if (!existsSync6(expectedCSS)) {
+  if (!existsSync7(bundlePath)) {
+    console.error(source_default.red(`Build did not emit ${expectedBundle}`));
+    process.exit(1);
+  }
+  const expectedCSS = join7(distDir, `space-${m.id}.css`);
+  if (!existsSync7(expectedCSS)) {
     const cssMatches = readdirSync3(distDir).filter((f) => f.endsWith(".css"));
     const renamedCSS = cssMatches.find((f) => f.startsWith("space-")) || (cssMatches.length === 1 ? cssMatches[0] : undefined);
     if (renamedCSS)
-      renameSync(join6(distDir, renamedCSS), expectedCSS);
+      renameSync(join7(distDir, renamedCSS), expectedCSS);
+  }
+  if (!existsSync7(expectedCSS)) {
+    console.error(source_default.red(`Build did not emit CSS. Spaces must import src/style.css so pages and widgets are self-contained.`));
+    process.exit(1);
   }
   const bundleData = readFileSync4(bundlePath);
-  const checksum = createHash("sha256").update(bundleData).digest("hex");
+  const checksum = createHash2("sha256").update(bundleData).digest("hex");
   const raw = readRaw(root);
-  const actionsPath = join6(root, "src", "actions.ts");
-  if (existsSync6(actionsPath)) {
+  const actionsPath = join7(root, "src", "actions.ts");
+  if (existsSync7(actionsPath)) {
     const actionMeta = extractActionMetadata(actionsPath);
     if (actionMeta && Object.keys(actionMeta).length > 0) {
       raw.actions = actionMeta;
@@ -8673,17 +8829,29 @@ async function build(options) {
   writeWithBuild(distDir, raw, {
     checksum,
     size: bundleData.length,
-    hostApiVersion: "0.5.0",
+    hostApiVersion: HOST_API_VERSION,
     builtAt: new Date().toISOString()
   });
-  console.log(source_default.green(`Built ${m.name} v${m.version}`));
+  const spaceBundle = createSpaceBundle({
+    distDir,
+    spaceId: m.id,
+    appBundlePath: bundlePath,
+    cssPath: expectedCSS
+  });
+  for (const entry of readdirSync3(distDir)) {
+    if (entry === `${m.id}.space`)
+      continue;
+    rmSync2(join7(distDir, entry), { recursive: true, force: true });
+  }
+  console.log(source_default.green(`Built ${m.name} v${m.version} -> dist/${m.id}.space`));
+  console.log(source_default.dim(`  ${spaceBundle.files.length} files, ${spaceBundle.hasStyle ? "style.css included" : "no style.css"}`));
 }
 
 // src/commands/dev.ts
 init_source();
-import { existsSync as existsSync7, readFileSync as readFileSync5 } from "fs";
-import { join as join9 } from "path";
-import { createHash as createHash2 } from "crypto";
+import { existsSync as existsSync8, readFileSync as readFileSync5 } from "fs";
+import { join as join10 } from "path";
+import { createHash as createHash3 } from "crypto";
 
 // node_modules/chokidar/index.js
 import { EventEmitter } from "events";
@@ -9413,9 +9581,9 @@ class NodeFsHandler {
     if (this.fsw.closed) {
       return;
     }
-    const dirname3 = sp.dirname(file);
+    const dirname4 = sp.dirname(file);
     const basename4 = sp.basename(file);
-    const parent = this.fsw._getWatchedDir(dirname3);
+    const parent = this.fsw._getWatchedDir(dirname4);
     let prevStats = stats;
     if (parent.has(basename4))
       return;
@@ -9442,7 +9610,7 @@ class NodeFsHandler {
             prevStats = newStats2;
           }
         } catch (error2) {
-          this.fsw._remove(dirname3, basename4);
+          this.fsw._remove(dirname4, basename4);
         }
       } else if (parent.has(basename4)) {
         const at = newStats.atimeMs;
@@ -9665,11 +9833,11 @@ function createPattern(matcher) {
       if (matcher.path === string)
         return true;
       if (matcher.recursive) {
-        const relative4 = sp2.relative(matcher.path, string);
-        if (!relative4) {
+        const relative5 = sp2.relative(matcher.path, string);
+        if (!relative5) {
           return false;
         }
-        return !relative4.startsWith("..") && !sp2.isAbsolute(relative4);
+        return !relative5.startsWith("..") && !sp2.isAbsolute(relative5);
       }
       return false;
     };
@@ -10299,8 +10467,8 @@ function watch(paths, options = {}) {
 // src/commands/dev.ts
 function getEntryWatchPaths(root) {
   return [
-    join9(root, MANIFEST_FILE),
-    join9(root, "src", "actions.ts")
+    join10(root, MANIFEST_FILE),
+    join10(root, "src", "actions.ts")
   ];
 }
 async function dev() {
@@ -10339,26 +10507,59 @@ async function dev() {
     }
     console.log(source_default.blue("Actions changed -- entry regenerated"));
   });
-  const distDir = join9(root, "dist");
-  const bundleFile = join9(distDir, `space-${m.id}.iife.js`);
+  const distDir = join10(root, "dist");
+  const bundleFile = join10(distDir, `space-${m.id}.iife.js`);
+  const cssFile = join10(distDir, `space-${m.id}.css`);
   let lastChecksum = "";
-  const distWatcher = watch(bundleFile, { ignoreInitial: false });
-  distWatcher.on("all", () => {
-    if (!existsSync7(bundleFile))
+  const packageSpace = (force = false) => {
+    if (!existsSync8(bundleFile) || !existsSync8(cssFile))
       return;
     const bundleData = readFileSync5(bundleFile);
-    const checksum = createHash2("sha256").update(bundleData).digest("hex");
-    if (checksum === lastChecksum)
+    const checksum = createHash3("sha256").update(bundleData).digest("hex");
+    if (!force && checksum === lastChecksum)
       return;
     lastChecksum = checksum;
     const raw = readRaw(root);
     writeWithBuild(distDir, raw, {
       checksum,
       size: bundleData.length,
-      hostApiVersion: "0.5.0",
+      hostApiVersion: HOST_API_VERSION,
       builtAt: new Date().toISOString()
     });
-    console.log(source_default.green(`Built -> dist/ (${(bundleData.length / 1024).toFixed(1)} KB)`));
+    stageSpaceResources(root, distDir);
+    buildSpaceTools(root, distDir, m.id);
+    createSpaceBundle({
+      distDir,
+      spaceId: m.id,
+      appBundlePath: bundleFile,
+      cssPath: cssFile
+    });
+    console.log(source_default.green(`Built -> dist/${m.id}.space (${(bundleData.length / 1024).toFixed(1)} KB)`));
+  };
+  const distWatcher = watch([bundleFile, cssFile], { ignoreInitial: false });
+  distWatcher.on("all", () => {
+    try {
+      packageSpace();
+    } catch (err) {
+      console.error(source_default.red(err?.message || String(err)));
+    }
+  });
+  const resourceWatcher = watch([
+    join10(root, "tools.go"),
+    join10(root, "tools"),
+    join10(root, "lib"),
+    join10(root, "agent"),
+    join10(root, "scripts"),
+    join10(root, "references"),
+    join10(root, "assets"),
+    join10(root, "SKILL.md")
+  ], { ignoreInitial: true });
+  resourceWatcher.on("all", () => {
+    try {
+      packageSpace(true);
+    } catch (err) {
+      console.error(source_default.red(err?.message || String(err)));
+    }
   });
   console.log(source_default.green("Watching for changes... (Ctrl+C to stop)"));
   console.log(source_default.dim("Use the Preview button in Construct to open the Space Runner"));
@@ -10367,19 +10568,16 @@ async function dev() {
 
 // src/commands/run.ts
 init_source();
-import { existsSync as existsSync9, cpSync as cpSync2, mkdirSync as mkdirSync3, readdirSync as readdirSync4, chmodSync, lstatSync, rmSync } from "fs";
-import { join as join11 } from "path";
+import { existsSync as existsSync10, cpSync as cpSync2, mkdirSync as mkdirSync5, readdirSync as readdirSync4, chmodSync, lstatSync as lstatSync2, rmSync as rmSync3 } from "fs";
+import { join as join12 } from "path";
 init_appdir();
-function ensureBinExecutable(installDir) {
+function ensureExecutableResources(installDir) {
   if (process.platform === "win32")
     return;
-  const binRoot = join11(installDir, "bin");
-  if (!existsSync9(binRoot))
-    return;
   const walk = (dir) => {
     for (const name of readdirSync4(dir)) {
-      const path = join11(dir, name);
-      const st = lstatSync(path);
+      const path = join12(dir, name);
+      const st = lstatSync2(path);
       if (st.isSymbolicLink())
         continue;
       if (st.isDirectory()) {
@@ -10389,7 +10587,11 @@ function ensureBinExecutable(installDir) {
       }
     }
   };
-  walk(binRoot);
+  for (const dirname5 of ["tools", "lib"]) {
+    const root = join12(installDir, dirname5);
+    if (existsSync10(root))
+      walk(root);
+  }
 }
 function install() {
   const root = process.cwd();
@@ -10397,34 +10599,36 @@ function install() {
     console.error(source_default.red("No space.manifest.json found in current directory"));
     process.exit(1);
   }
-  const distDir = join11(root, "dist");
-  if (!existsSync9(distDir)) {
+  const distDir = join12(root, "dist");
+  if (!existsSync10(distDir)) {
     console.error(source_default.red("No dist/ directory found. Run 'construct build' first."));
     process.exit(1);
   }
   const m = read(root);
-  const agentDir = join11(root, "agent");
-  if (existsSync9(agentDir)) {
-    bundleAgentDir(agentDir, distDir);
+  const bundleDir = join12(distDir, `${m.id}.space`);
+  if (!existsSync10(bundleDir)) {
+    console.error(source_default.red(`No dist/${m.id}.space directory found. Run 'construct build' first.`));
+    process.exit(1);
   }
   const installDir = spaceDir(m.id);
-  rmSync(installDir, { recursive: true, force: true });
-  mkdirSync3(installDir, { recursive: true });
-  cpSync2(distDir, installDir, { recursive: true, verbatimSymlinks: true, force: true });
-  ensureBinExecutable(installDir);
+  rmSync3(join12(spacesDir(), m.id), { recursive: true, force: true });
+  rmSync3(installDir, { recursive: true, force: true });
+  mkdirSync5(installDir, { recursive: true });
+  cpSync2(bundleDir, installDir, { recursive: true, verbatimSymlinks: true, force: true });
+  ensureExecutableResources(installDir);
   console.log(source_default.green(`Installed ${m.name} -> ${installDir}`));
   console.log(source_default.dim("  Restart Construct to load the updated space."));
 }
 
 // src/commands/publish.ts
 init_source();
-import { readFileSync as readFileSync8, writeFileSync as writeFileSync6, statSync as statSync5, unlinkSync as unlinkSync2 } from "fs";
-import { join as join14, basename as basename5 } from "path";
+import { readFileSync as readFileSync8, writeFileSync as writeFileSync6, statSync as statSync4, unlinkSync as unlinkSync2 } from "fs";
+import { join as join15, basename as basename5 } from "path";
 init_auth();
 
 // src/lib/pack.ts
-import { readdirSync as readdirSync6, statSync as statSync4, existsSync as existsSync11 } from "fs";
-import { join as join13 } from "path";
+import { readdirSync as readdirSync6, statSync as statSync3, existsSync as existsSync12 } from "fs";
+import { join as join14 } from "path";
 import { tmpdir } from "os";
 import { execFileSync as execFileSync2 } from "child_process";
 var allowedDirs = [
@@ -10447,7 +10651,9 @@ var allowedDirs = [
   "icons",
   "assets",
   "media",
-  "bin"
+  "tools",
+  "lib",
+  "go-tools"
 ];
 var allowedRootFiles = [
   "space.manifest.json",
@@ -10457,20 +10663,24 @@ var allowedRootFiles = [
   "vite.config.js",
   "space.config.ts",
   "types.ts",
-  "index.ts"
+  "index.ts",
+  "SKILL.md",
+  "tools.go",
+  "go.mod",
+  "go.sum"
 ];
 var allowedRootPatterns = [/.*\.config\.ts$/, /.*\.config\.js$/];
 var blockedExtensions = [".env", ".log", ".lock", ".lockb"];
 var MAX_SIZE = 50 * 1024 * 1024;
 async function packSource(root) {
-  const tarballPath = join13(tmpdir(), `space-source-${Date.now()}.tar.gz`);
+  const tarballPath = join14(tmpdir(), `space-source-${Date.now()}.tar.gz`);
   const entries = [];
   for (const name of allowedRootFiles) {
-    if (existsSync11(join13(root, name)))
+    if (existsSync12(join14(root, name)))
       entries.push(name);
   }
   for (const entry of readdirSync6(root)) {
-    if (statSync4(join13(root, entry)).isDirectory())
+    if (statSync3(join14(root, entry)).isDirectory())
       continue;
     if (allowedRootFiles.includes(entry))
       continue;
@@ -10480,10 +10690,10 @@ async function packSource(root) {
       entries.push(entry);
   }
   for (const dir of allowedDirs) {
-    if (existsSync11(join13(root, dir)))
+    if (existsSync12(join14(root, dir)))
       entries.push(dir);
   }
-  const validEntries = entries.filter((e) => existsSync11(join13(root, e)));
+  const validEntries = entries.filter((e) => existsSync12(join14(root, e)));
   if (validEntries.length === 0) {
     throw new Error("No files to pack");
   }
@@ -10491,13 +10701,15 @@ async function packSource(root) {
     "--exclude=node_modules",
     "--exclude=dist",
     "--exclude=.git",
+    "--exclude=go-tools/spaceprobe",
+    "--exclude=go-tools/spaceprobe.exe",
     "--exclude=*.env",
     "--exclude=*.log",
     "--exclude=*.lock",
     "--exclude=*.lockb"
   ];
   execFileSync2("tar", ["czf", tarballPath, ...excludes, ...validEntries], { cwd: root });
-  const size = statSync4(tarballPath).size;
+  const size = statSync3(tarballPath).size;
   if (size > MAX_SIZE) {
     throw new Error(`Source exceeds maximum size of ${MAX_SIZE / 1024 / 1024}MB`);
   }
@@ -10576,7 +10788,7 @@ function setVersionInFiles(root, oldVer, newVer) {
   const oldStr = `"version": "${oldVer}"`;
   const newStr = `"version": "${newVer}"`;
   for (const file of ["package.json", "space.manifest.json"]) {
-    const path = join14(root, file);
+    const path = join15(root, file);
     try {
       const data = readFileSync8(path, "utf-8");
       writeFileSync6(path, data.replace(oldStr, newStr));
@@ -10735,7 +10947,7 @@ async function publish(options) {
   let tarballPath;
   try {
     tarballPath = await packSource(root);
-    const size = statSync5(tarballPath).size;
+    const size = statSync4(tarballPath).size;
     spinner.succeed(`Source packed (${formatBytes(size)})`);
   } catch (err) {
     spinner.fail("Pack failed");
@@ -10803,8 +11015,8 @@ async function publish(options) {
 
 // src/commands/validate.ts
 init_source();
-import { existsSync as existsSync12, readFileSync as readFileSync9 } from "fs";
-import { join as join15 } from "path";
+import { existsSync as existsSync13, readFileSync as readFileSync9 } from "fs";
+import { join as join16 } from "path";
 
 // src/lib/pagePaths.ts
 function pageComponentFromPath(path) {
@@ -10838,21 +11050,21 @@ function validate3() {
   let warnings = 0;
   for (const page of m.pages) {
     const component = page.component || pageComponentFromPath(page.path);
-    const fullPath = join15(root, "src", component);
-    if (!existsSync12(fullPath)) {
+    const fullPath = join16(root, "src", component);
+    if (!existsSync13(fullPath)) {
       console.log(source_default.yellow(`  \u26A0 Page component not found: src/${component}`));
       warnings++;
     }
   }
   if (m.agent) {
-    const agentPath = join15(root, m.agent);
-    if (!existsSync12(agentPath)) {
+    const agentPath = join16(root, m.agent);
+    if (!existsSync13(agentPath)) {
       console.log(source_default.yellow(`  \u26A0 Agent config not found: ${m.agent}`));
       warnings++;
     }
   }
-  const pkgPath = join15(root, "package.json");
-  if (existsSync12(pkgPath)) {
+  const pkgPath = join16(root, "package.json");
+  if (existsSync13(pkgPath)) {
     const pkg = JSON.parse(readFileSync9(pkgPath, "utf-8"));
     if (pkg.version && pkg.version !== m.version) {
       console.log(source_default.yellow(`  \u26A0 Version mismatch: manifest=${m.version} package.json=${pkg.version}`));
@@ -10869,8 +11081,8 @@ function validate3() {
 // src/commands/check.ts
 init_source();
 import { execSync as execSync2 } from "child_process";
-import { existsSync as existsSync13, readFileSync as readFileSync10 } from "fs";
-import { join as join16 } from "path";
+import { existsSync as existsSync14, readFileSync as readFileSync10 } from "fs";
+import { join as join17 } from "path";
 function check() {
   const root = process.cwd();
   if (!exists(root)) {
@@ -10889,17 +11101,17 @@ function check() {
   let warnings = 0;
   for (const page of m.pages) {
     const component = page.component || pageComponentFromPath(page.path);
-    if (!existsSync13(join16(root, "src", component))) {
+    if (!existsSync14(join17(root, "src", component))) {
       console.log(source_default.yellow(`  \u26A0 Page not found: src/${component}`));
       warnings++;
     }
   }
-  if (m.agent && !existsSync13(join16(root, m.agent))) {
+  if (m.agent && !existsSync14(join17(root, m.agent))) {
     console.log(source_default.yellow(`  \u26A0 Agent config not found: ${m.agent}`));
     warnings++;
   }
-  const pkgPath = join16(root, "package.json");
-  if (existsSync13(pkgPath)) {
+  const pkgPath = join17(root, "package.json");
+  if (existsSync14(pkgPath)) {
     const pkg = JSON.parse(readFileSync10(pkgPath, "utf-8"));
     if (pkg.version && pkg.version !== m.version) {
       console.log(source_default.yellow(`  \u26A0 Version mismatch: manifest=${m.version} package.json=${pkg.version}`));
@@ -10932,8 +11144,8 @@ function check() {
 
 // src/commands/clean.ts
 init_source();
-import { rmSync as rmSync2, existsSync as existsSync14 } from "fs";
-import { join as join17 } from "path";
+import { rmSync as rmSync4, existsSync as existsSync15 } from "fs";
+import { join as join18 } from "path";
 function clean(options) {
   const root = process.cwd();
   const dirs = ["dist", ".vite"];
@@ -10942,17 +11154,17 @@ function clean(options) {
   }
   const lockfiles = ["bun.lockb", "package-lock.json", "yarn.lock", "pnpm-lock.yaml"];
   for (const dir of dirs) {
-    const path = join17(root, dir);
-    if (existsSync14(path)) {
-      rmSync2(path, { recursive: true });
+    const path = join18(root, dir);
+    if (existsSync15(path)) {
+      rmSync4(path, { recursive: true });
       console.log(source_default.dim(`  Removed ${dir}/`));
     }
   }
   if (options?.all) {
     for (const file of lockfiles) {
-      const path = join17(root, file);
-      if (existsSync14(path)) {
-        rmSync2(path);
+      const path = join18(root, file);
+      if (existsSync15(path)) {
+        rmSync4(path);
         console.log(source_default.dim(`  Removed ${file}`));
       }
     }
@@ -11112,8 +11324,8 @@ function update() {
 
 // src/commands/graph/init.ts
 init_source();
-import { existsSync as existsSync15, readFileSync as readFileSync11, writeFileSync as writeFileSync7, mkdirSync as mkdirSync5 } from "fs";
-import { join as join18 } from "path";
+import { existsSync as existsSync16, readFileSync as readFileSync11, writeFileSync as writeFileSync7, mkdirSync as mkdirSync7 } from "fs";
+import { join as join19 } from "path";
 import { execSync as execSync4 } from "child_process";
 function graphInit() {
   const root = process.cwd();
@@ -11123,10 +11335,10 @@ function graphInit() {
     process.exit(1);
   }
   const m = read(root);
-  const modelsDir = join18(root, "src", "models");
-  mkdirSync5(modelsDir, { recursive: true });
-  const indexPath = join18(modelsDir, "index.ts");
-  if (!existsSync15(indexPath)) {
+  const modelsDir = join19(root, "src", "models");
+  mkdirSync7(modelsDir, { recursive: true });
+  const indexPath = join19(modelsDir, "index.ts");
+  if (!existsSync16(indexPath)) {
     writeFileSync7(indexPath, `// Data models for ${m.name}
 // Generated by construct graph init
 
@@ -11134,7 +11346,7 @@ function graphInit() {
 // export { User } from './User'
 `);
   }
-  const pkgPath = join18(root, "package.json");
+  const pkgPath = join19(root, "package.json");
   const pkg = JSON.parse(readFileSync11(pkgPath, "utf-8"));
   if (!pkg.dependencies)
     pkg.dependencies = {};
@@ -11166,8 +11378,8 @@ function graphInit() {
 
 // src/commands/graph/generate.ts
 init_source();
-import { existsSync as existsSync16, readFileSync as readFileSync12, writeFileSync as writeFileSync8, mkdirSync as mkdirSync6 } from "fs";
-import { join as join19 } from "path";
+import { existsSync as existsSync17, readFileSync as readFileSync12, writeFileSync as writeFileSync8, mkdirSync as mkdirSync8 } from "fs";
+import { join as join20 } from "path";
 var FIELD_TYPES = {
   string: "field.string()",
   int: "field.int()",
@@ -11319,10 +11531,10 @@ function generate2(modelName, fieldSpecs, options) {
   lines.push("");
   const content = lines.join(`
 `);
-  const modelsDir = join19(root, "src", "models");
-  mkdirSync6(modelsDir, { recursive: true });
-  const filePath = join19(modelsDir, `${name}.ts`);
-  if (existsSync16(filePath)) {
+  const modelsDir = join20(root, "src", "models");
+  mkdirSync8(modelsDir, { recursive: true });
+  const filePath = join20(modelsDir, `${name}.ts`);
+  if (existsSync17(filePath)) {
     console.log(source_default.yellow(`  Model file already exists: src/models/${name}.ts`));
     console.log(source_default.dim("  Overwriting..."));
   }
@@ -11339,9 +11551,9 @@ function generate2(modelName, fieldSpecs, options) {
   console.log();
 }
 function updateBarrel(modelsDir, modelName) {
-  const indexPath = join19(modelsDir, "index.ts");
+  const indexPath = join20(modelsDir, "index.ts");
   const exportLine = `export { ${modelName} } from './${modelName}'`;
-  if (existsSync16(indexPath)) {
+  if (existsSync17(indexPath)) {
     const content = readFileSync12(indexPath, "utf-8");
     if (content.includes(exportLine))
       return;
@@ -11357,8 +11569,8 @@ function updateBarrel(modelsDir, modelName) {
 
 // src/commands/graph/push.ts
 init_source();
-import { existsSync as existsSync17, readdirSync as readdirSync7, readFileSync as readFileSync13 } from "fs";
-import { join as join20 } from "path";
+import { existsSync as existsSync18, readdirSync as readdirSync7, readFileSync as readFileSync13 } from "fs";
+import { join as join21 } from "path";
 init_auth();
 async function graphPush() {
   const root = process.cwd();
@@ -11367,8 +11579,8 @@ async function graphPush() {
     process.exit(1);
   }
   const m = read(root);
-  const modelsDir = join20(root, "src", "models");
-  if (!existsSync17(modelsDir)) {
+  const modelsDir = join21(root, "src", "models");
+  if (!existsSync18(modelsDir)) {
     console.error(source_default.red("No src/models/ directory found. Run 'construct graph init' first."));
     process.exit(1);
   }
@@ -11381,7 +11593,7 @@ async function graphPush() {
   console.log(source_default.blue(`Pushing ${modelFiles.length} model(s) for space: ${m.id}`));
   const models = [];
   for (const file of modelFiles) {
-    const content = readFileSync13(join20(modelsDir, file), "utf-8");
+    const content = readFileSync13(join21(modelsDir, file), "utf-8");
     const model = parseModelFile(content);
     if (model)
       models.push(model);
@@ -11564,8 +11776,8 @@ function parseModelFile(content) {
 
 // src/commands/graph/migrate.ts
 init_source();
-import { existsSync as existsSync18, readdirSync as readdirSync8, readFileSync as readFileSync14 } from "fs";
-import { join as join21 } from "path";
+import { existsSync as existsSync19, readdirSync as readdirSync8, readFileSync as readFileSync14 } from "fs";
+import { join as join22 } from "path";
 init_auth();
 async function graphMigrate(options) {
   const root = process.cwd();
@@ -11574,8 +11786,8 @@ async function graphMigrate(options) {
     process.exit(1);
   }
   const m = read(root);
-  const modelsDir = join21(root, "src", "models");
-  if (!existsSync18(modelsDir)) {
+  const modelsDir = join22(root, "src", "models");
+  if (!existsSync19(modelsDir)) {
     console.error(source_default.red("No src/models/ directory. Run 'construct graph init' first."));
     process.exit(1);
   }
@@ -11605,7 +11817,7 @@ async function graphMigrate(options) {
   const modelFiles = readdirSync8(modelsDir).filter((f) => f.endsWith(".ts") && f !== "index.ts");
   const localModels = [];
   for (const file of modelFiles) {
-    const content = readFileSync14(join21(modelsDir, file), "utf-8");
+    const content = readFileSync14(join22(modelsDir, file), "utf-8");
     const model = parseModelFields(content);
     if (model)
       localModels.push(model);
@@ -11741,7 +11953,7 @@ function graphFork(newSpaceID) {
 // package.json
 var package_default = {
   name: "@construct-space/cli",
-  version: "1.9.5",
+  version: "1.9.6",
   description: "Construct CLI \u2014 scaffold, build, develop, and publish spaces",
   type: "module",
   bin: {