@goondocks/myco 0.18.1 → 0.19.1

package/dist/{chunk-75AZFBFW.js → chunk-6ZDJXSEO.js}

@@ -2,10 +2,10 @@ import { createRequire as __cr } from 'node:module'; const require = __cr(import
 import {
   LmStudioBackend,
   OllamaBackend
-} from "./chunk-CML4MCYF.js";
+} from "./chunk-PMT2LSTQ.js";
 import {
   PROVIDER_DETECT_TIMEOUT_MS
-} from "./chunk-CKJAWZQE.js";
+} from "./chunk-I54KLC6H.js";
 
 // src/intelligence/provider-check.ts
 async function checkLocalProvider(type, baseUrl) {
@@ -19,4 +19,4 @@ async function checkLocalProvider(type, baseUrl) {
 export {
   checkLocalProvider
 };
-//# sourceMappingURL=chunk-75AZFBFW.js.map
+//# sourceMappingURL=chunk-6ZDJXSEO.js.map

package/dist/{chunk-TLK46KKD.js → chunk-AOCBCPAP.js}

@@ -5,7 +5,7 @@ import {
 import {
   LmStudioBackend,
   OllamaBackend
-} from "./chunk-CML4MCYF.js";
+} from "./chunk-PMT2LSTQ.js";
 import {
   closeDatabase,
   initDatabase,
@@ -13,7 +13,7 @@ import {
 } from "./chunk-MYX5NCRH.js";
 import {
   DaemonClient
-} from "./chunk-XWOQL4XN.js";
+} from "./chunk-NU74DHV3.js";
 
 // src/cli/shared.ts
 import fs from "fs";
@@ -76,8 +76,8 @@ restart-reason.json
 # Binary attachments \u2014 screenshots captured from transcripts
 attachments/
 
-# Team worker deployment \u2014 patched wrangler.toml + source copy
-.team-worker/
+# Team sync admin state + worker deployment
+team/
 
 # Runtime command alias \u2014 per-contributor override for which myco binary
 # the hook guard invokes. Default (file absent) is \`myco\`; \`make dev-link\`
@@ -120,4 +120,4 @@ export {
   VAULT_GITIGNORE,
   registerSymbionts
 };
-//# sourceMappingURL=chunk-TLK46KKD.js.map
+//# sourceMappingURL=chunk-AOCBCPAP.js.map

package/dist/chunk-AOCBCPAP.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/cli/shared.ts"],"sourcesContent":["import fs from 'node:fs';\nimport path from 'node:path';\nimport os from 'node:os';\nimport { OllamaBackend } from '../intelligence/ollama.js';\nimport { LmStudioBackend } from '../intelligence/lm-studio.js';\n\nimport { DaemonClient } from '../hooks/client.js';\nimport { initDatabase, closeDatabase, vaultDbPath } from '../db/client.js';\nimport { SymbiontInstaller } from '../symbionts/installer.js';\nimport type { SymbiontManifest } from '../symbionts/manifest-schema.js';\n\nexport { parseStringFlag, parseIntFlag } from '../logs/format.js';\n\n/**\n * Initialize the singleton database for direct CLI reads.\n * Used by CLI commands that only need reads (stats, search, session).\n * Does NOT require the daemon to be running — WAL mode allows concurrent reads.\n *\n * @returns a cleanup function that closes the database.\n */\nexport function initVaultDb(vaultDir: string): () => void {\n  initDatabase(vaultDbPath(vaultDir));\n  return closeDatabase;\n}\n\n/** Connect to the daemon, ensuring it's running. Exits on failure. */\nexport async function connectToDaemon(vaultDir: string): Promise<DaemonClient> {\n  const client = new DaemonClient(vaultDir);\n  const healthy = await client.ensureRunning();\n  if (!healthy) {\n    console.error('Failed to connect to daemon');\n    process.exit(1);\n  }\n  return client;\n}\n\n/** Load .env from cwd (not script location — that's the plugin install dir). */\nexport function loadEnv(): void {\n  const envPath = path.resolve(process.cwd(), '.env');\n  if (!fs.existsSync(envPath)) return;\n  for (const line of fs.readFileSync(envPath, 'utf-8').split('\\n')) {\n    const match = line.match(/^\\s*([^#=]+?)\\s*=\\s*(.*?)\\s*$/);\n    if (match && !process.env[match[1]]) {\n      process.env[match[1]] = match[2];\n    }\n  }\n}\n\nexport function isProcessAlive(pid: number): boolean {\n  try { process.kill(pid, 0); return true; } catch { return false; }\n}\n\n// --- Provider defaults (sourced from backend classes) ---\nexport const PROVIDER_DEFAULTS: Record<string, { base_url: string }> = {\n  ollama: { base_url: OllamaBackend.DEFAULT_BASE_URL },\n  'lm-studio': { base_url: LmStudioBackend.DEFAULT_BASE_URL },\n};\n\n\nexport const VAULT_GITIGNORE = `# SQLite database\nmyco.db*\nvectors.db*\n\n# Daemon state — per-machine, ephemeral\ndaemon.json\nbuffer/\nlogs/\n\n# Secrets — API keys for cloud providers\nsecrets.env\n\n# Machine ID\nmachine_id\n\n# Update tracking — per-machine state\nlast-update-version\nrestart-reason.json\n\n# Binary attachments — screenshots captured from transcripts\nattachments/\n\n# Team sync admin state + worker deployment\nteam/\n\n# Runtime command alias — per-contributor override for which myco binary\n# the hook guard invokes. Default (file absent) is \\`myco\\`; \\`make dev-link\\`\n# writes \\`myco-dev\\`; users can hand-edit for PATH conflicts or pinning.\n# Never committed — different contributors use different aliases.\nruntime.command\n`;\n\n/** Collapse an absolute home-dir path to its `~/` form for portable config storage. */\nexport function collapseHomePath(absPath: string): string {\n  const home = os.homedir();\n  if (absPath.startsWith(home + path.sep) || absPath === home) {\n    return '~' + absPath.slice(home.length);\n  }\n  return absPath;\n}\n\n/**\n * Run the SymbiontInstaller for each symbiont manifest and log results.\n * Shared between myco init and myco update.\n */\nexport function registerSymbionts(\n  manifests: SymbiontManifest[],\n  projectRoot: string,\n  packageRoot: string,\n  verb: 'Registered' | 'Updated',\n): number {\n  let count = 0;\n  for (const manifest of manifests) {\n    try {\n      const installer = new SymbiontInstaller(manifest, projectRoot, packageRoot);\n      const result = installer.install();\n\n      const installed = [\n        result.hooks && 'hooks',\n        result.mcp && 'MCP server',\n        result.skills && 'skills',\n        result.settings && 'settings',\n        result.instructions && 'instructions',\n        result.pluginPackage && 'plugin deps',\n      ].filter(Boolean);\n\n      if (installed.length > 0) {\n        console.log(`  \\u2713 ${verb} ${manifest.displayName}: ${installed.join(', ')}`);\n        count++;\n      } else {\n        console.log(`  \\u2013 ${manifest.displayName}: no registration targets configured`);\n      }\n    } catch (err) {\n      console.error(`  \\u2717 Failed to register ${manifest.displayName}: ${(err as Error).message}`);\n    }\n  }\n  return count;\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;AAAA,OAAO,QAAQ;AACf,OAAO,UAAU;AACjB,OAAO,QAAQ;AAkBR,SAAS,YAAY,UAA8B;AACxD,eAAa,YAAY,QAAQ,CAAC;AAClC,SAAO;AACT;AAGA,eAAsB,gBAAgB,UAAyC;AAC7E,QAAM,SAAS,IAAI,aAAa,QAAQ;AACxC,QAAM,UAAU,MAAM,OAAO,cAAc;AAC3C,MAAI,CAAC,SAAS;AACZ,YAAQ,MAAM,6BAA6B;AAC3C,YAAQ,KAAK,CAAC;AAAA,EAChB;AACA,SAAO;AACT;AAGO,SAAS,UAAgB;AAC9B,QAAM,UAAU,KAAK,QAAQ,QAAQ,IAAI,GAAG,MAAM;AAClD,MAAI,CAAC,GAAG,WAAW,OAAO,EAAG;AAC7B,aAAW,QAAQ,GAAG,aAAa,SAAS,OAAO,EAAE,MAAM,IAAI,GAAG;AAChE,UAAM,QAAQ,KAAK,MAAM,+BAA+B;AACxD,QAAI,SAAS,CAAC,QAAQ,IAAI,MAAM,CAAC,CAAC,GAAG;AACnC,cAAQ,IAAI,MAAM,CAAC,CAAC,IAAI,MAAM,CAAC;AAAA,IACjC;AAAA,EACF;AACF;AAEO,SAAS,eAAe,KAAsB;AACnD,MAAI;AAAE,YAAQ,KAAK,KAAK,CAAC;AAAG,WAAO;AAAA,EAAM,QAAQ;AAAE,WAAO;AAAA,EAAO;AACnE;AAGO,IAAM,oBAA0D;AAAA,EACrE,QAAQ,EAAE,UAAU,cAAc,iBAAiB;AAAA,EACnD,aAAa,EAAE,UAAU,gBAAgB,iBAAiB;AAC5D;AAGO,IAAM,kBAAkB;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AA6CxB,SAAS,kBACd,WACA,aACA,aACA,MACQ;AACR,MAAI,QAAQ;AACZ,aAAW,YAAY,WAAW;AAChC,QAAI;AACF,YAAM,YAAY,IAAI,kBAAkB,UAAU,aAAa,WAAW;AAC1E,YAAM,SAAS,UAAU,QAAQ;AAEjC,YAAM,YAAY;AAAA,QAChB,OAAO,SAAS;AAAA,QAChB,OAAO,OAAO;AAAA,QACd,OAAO,UAAU;AAAA,QACjB,OAAO,YAAY;AAAA,QACnB,OAAO,gBAAgB;AAAA,QACvB,OAAO,iBAAiB;AAAA,MAC1B,EAAE,OAAO,OAAO;AAEhB,UAAI,UAAU,SAAS,GAAG;AACxB,gBAAQ,IAAI,YAAY,IAAI,IAAI,SAAS,WAAW,KAAK,UAAU,KAAK,IAAI,CAAC,EAAE;AAC/E;AAAA,MACF,OAAO;AACL,gBAAQ,IAAI,YAAY,SAAS,WAAW,sCAAsC;AAAA,MACpF;AAAA,IACF,SAAS,KAAK;AACZ,cAAQ,MAAM,+BAA+B,SAAS,WAAW,KAAM,IAAc,OAAO,EAAE;AAAA,IAChG;AAAA,EACF;AACA,SAAO;AACT;","names":[]}

package/dist/{chunk-O3TRN3RC.js → chunk-AULBWINA.js}

@@ -4,7 +4,7 @@ import {
 } from "./chunk-MYX5NCRH.js";
 import {
   DEFAULT_MACHINE_ID
-} from "./chunk-CKJAWZQE.js";
+} from "./chunk-I54KLC6H.js";
 
 // src/daemon/team-context.ts
 var teamSyncEnabled = false;
@@ -224,4 +224,4 @@ export {
   markSourceRowsSynced,
   backfillUnsynced
 };
-//# sourceMappingURL=chunk-O3TRN3RC.js.map
+//# sourceMappingURL=chunk-AULBWINA.js.map

package/dist/chunk-CDM6ZLMZ.js

@@ -0,0 +1,598 @@
+import { createRequire as __cr } from 'node:module'; const require = __cr(import.meta.url);
+import {
+  SCHEMA_VERSION
+} from "./chunk-6DDRJQ4X.js";
+import {
+  loadConfig,
+  updateTeamConfig
+} from "./chunk-4NIMDUYW.js";
+import {
+  TEAM_API_KEY_SECRET,
+  TEAM_MCP_TOKEN_SECRET,
+  WRANGLER_COMMAND_TIMEOUT_MS
+} from "./chunk-I54KLC6H.js";
+
+// ../myco-team/src/cli.ts
+import crypto2 from "crypto";
+import fs4 from "fs";
+import path4 from "path";
+import { fileURLToPath } from "url";
+
+// src/config/secrets.ts
+import fs from "fs";
+import path from "path";
+var SECRETS_FILE = "secrets.env";
+function readSecrets(vaultDir) {
+  const secretsPath = path.join(vaultDir, SECRETS_FILE);
+  if (!fs.existsSync(secretsPath)) return {};
+  const secrets = {};
+  for (const line of fs.readFileSync(secretsPath, "utf-8").split("\n")) {
+    const match = line.match(/^\s*([^#=]+?)\s*=\s*(.*?)\s*$/);
+    if (match) {
+      secrets[match[1]] = match[2];
+    }
+  }
+  return secrets;
+}
+function writeSecret(vaultDir, key, value) {
+  const secretsPath = path.join(vaultDir, SECRETS_FILE);
+  const existing = readSecrets(vaultDir);
+  existing[key] = value;
+  const content = Object.entries(existing).map(([k, v]) => `${k}=${v}`).join("\n") + "\n";
+  fs.writeFileSync(secretsPath, content, "utf-8");
+}
+function loadSecrets(vaultDir) {
+  const secrets = readSecrets(vaultDir);
+  for (const [key, value] of Object.entries(secrets)) {
+    if (!process.env[key]) {
+      process.env[key] = value;
+    }
+  }
+}
+
+// ../myco-deploy/src/cloudflare.ts
+import { execFileSync } from "child_process";
+import fs2 from "fs";
+import path2 from "path";
+var WORKER_URL_REGEX = /(https:\/\/[^\s]+\.workers\.dev)/;
+var D1_ID_JSON_REGEX = /"database_id"\s*:\s*"([0-9a-f-]{36})"/i;
+var D1_ID_TEXT_REGEX = /id:\s*([0-9a-f-]{36})/i;
+var KV_ID_REGEX = /"id":\s*"([0-9a-f]+)"/i;
+function buildCommandEnv() {
+  const nodeBinDir = path2.dirname(process.execPath);
+  const pathValue = process.env.PATH ? `${nodeBinDir}${path2.delimiter}${process.env.PATH}` : nodeBinDir;
+  return { ...process.env, PATH: pathValue };
+}
+function runWrangler(args, options) {
+  try {
+    return execFileSync("wrangler", args, {
+      cwd: options.cwd,
+      env: buildCommandEnv(),
+      input: options.input,
+      encoding: "utf-8",
+      timeout: options.timeoutMs,
+      stdio: ["pipe", "pipe", "pipe"]
+    });
+  } catch (error) {
+    const execError = error;
+    const stderr = execError.stderr?.toString() ?? "";
+    const stdout = execError.stdout?.toString() ?? "";
+    const detail = [stderr, stdout].filter(Boolean).join("\n").trim();
+    throw new Error(detail || execError.message);
+  }
+}
+function installDeploymentDeps(deployDir, timeoutMs) {
+  const packageJsonPath = path2.join(deployDir, "package.json");
+  if (!fs2.existsSync(packageJsonPath)) return;
+  execFileSync("npm", ["install", "--silent", "--no-audit", "--no-fund"], {
+    cwd: deployDir,
+    env: buildCommandEnv(),
+    encoding: "utf-8",
+    timeout: timeoutMs,
+    stdio: ["pipe", "pipe", "pipe"]
+  });
+}
+function parseWorkerUrl(output) {
+  const workerUrl = output.match(WORKER_URL_REGEX)?.[1];
+  if (!workerUrl) {
+    throw new Error(`Could not parse worker URL from deploy output:
+${output}`);
+  }
+  return workerUrl;
+}
+function parseD1Id(output) {
+  const jsonMatch = output.match(D1_ID_JSON_REGEX);
+  if (jsonMatch) return jsonMatch[1];
+  const textMatch = output.match(D1_ID_TEXT_REGEX);
+  if (textMatch) return textMatch[1];
+  throw new Error(`Could not parse D1 database ID from wrangler output:
+${output}`);
+}
+function parseKvNamespaceId(output) {
+  const kvId = output.match(KV_ID_REGEX)?.[1];
+  if (!kvId) {
+    throw new Error(`Could not parse KV namespace ID from wrangler output:
+${output}`);
+  }
+  return kvId;
+}
+function extractJsonArray(output) {
+  const start = output.indexOf("[");
+  const end = output.lastIndexOf("]");
+  if (start === -1 || end === -1 || end < start) {
+    throw new Error(`No JSON array found in output:
+${output}`);
+  }
+  return JSON.parse(output.slice(start, end + 1));
+}
+function stageDeploymentDir(options) {
+  if (options.reset) {
+    fs2.rmSync(options.deployDir, { recursive: true, force: true });
+  }
+  fs2.mkdirSync(options.deployDir, { recursive: true });
+  fs2.cpSync(options.sourceDir, options.deployDir, { recursive: true });
+  for (const copy of options.extraCopies ?? []) {
+    fs2.cpSync(copy.sourceDir, path2.join(options.deployDir, copy.destinationSubdir), { recursive: true });
+  }
+  for (const patch of options.textPatches ?? []) {
+    const absolutePath = path2.join(options.deployDir, patch.filePath);
+    let nextText = fs2.readFileSync(absolutePath, "utf-8");
+    for (const transform of patch.transforms) {
+      nextText = transform(nextText);
+    }
+    fs2.writeFileSync(absolutePath, nextText, "utf-8");
+  }
+  if (options.installDepsTimeoutMs) {
+    installDeploymentDeps(options.deployDir, options.installDepsTimeoutMs);
+  }
+  return options.deployDir;
+}
+
+// ../myco-deploy/src/local-config.ts
+import crypto from "crypto";
+import fs3 from "fs";
+import os from "os";
+import path3 from "path";
+var MYCO_HOME_OVERRIDE_ENV = "MYCO_HOME_OVERRIDE";
+function resolveHomeDir() {
+  return process.env[MYCO_HOME_OVERRIDE_ENV]?.trim() || os.homedir();
+}
+function resolveHomeConfigPath(configDir, fileName) {
+  return path3.join(resolveHomeDir(), configDir, fileName);
+}
+function resolveVaultConfigPath(vaultDir, configDir, fileName) {
+  return path3.join(vaultDir, configDir, fileName);
+}
+function readJsonConfig(configPath) {
+  if (!fs3.existsSync(configPath)) return null;
+  return JSON.parse(fs3.readFileSync(configPath, "utf-8"));
+}
+function writeJsonConfig(configPath, value) {
+  fs3.mkdirSync(path3.dirname(configPath), { recursive: true });
+  fs3.writeFileSync(configPath, `${JSON.stringify(value, null, 2)}
+`, { encoding: "utf-8", mode: 384 });
+  fs3.chmodSync(configPath, 384);
+}
+
+// ../myco-team/src/cli.ts
+var API_KEY_BYTES = 32;
+var VECTORIZE_DIMENSIONS = "1024";
+var VECTORIZE_METRIC = "cosine";
+var TEAM_RESOURCE_PREFIX = "myco-team";
+var PROJECT_HASH_LENGTH = 8;
+var WORKER_SOURCE_DIR = "worker";
+var TEAM_STATE_DIR = "team";
+var TEAM_DEPLOY_DIR = "worker";
+var TEAM_CONFIG_FILE = "config.json";
+var LEGACY_TEAM_CONFIG_DIR = ".myco-team";
+var LEGACY_TEAM_DEPLOY_DIR = ".team-worker";
+var TEAM_CONFIG_VERSION = 1;
+var TOML_NAME_REGEX = /^name\s*=\s*"[^"]*"/m;
+var TOML_D1_PLACEHOLDER_REGEX = /<YOUR_D1_DATABASE_ID>/g;
+var TOML_DB_NAME_REGEX = /database_name\s*=\s*"[^"]*"/g;
+var TOML_INDEX_NAME_REGEX = /index_name\s*=\s*"[^"]*"/g;
+var TOML_TEAM_PACKAGE_VERSION_REGEX = /MYCO_TEAM_PACKAGE_VERSION\s*=\s*"[^"]*"/g;
+var TOML_MYCO_SCHEMA_VERSION_REGEX = /MYCO_SCHEMA_VERSION\s*=\s*"[^"]*"/g;
+var TOML_DB_ID_REGEX = /database_id\s*=\s*"([^"]+)"/;
+var TOML_KV_PLACEHOLDER_REGEX = /<YOUR_KV_NAMESPACE_ID>/g;
+var TOML_KV_ID_REGEX = /\[\[kv_namespaces\]\][\s\S]*?id\s*=\s*"([0-9a-f]+)"/;
+function projectHash(vaultDir) {
+  const hash = crypto2.createHash("sha256").update(vaultDir).digest("hex");
+  return hash.slice(0, PROJECT_HASH_LENGTH);
+}
+function resourceName(vaultDir) {
+  return `${TEAM_RESOURCE_PREFIX}-${projectHash(vaultDir)}`;
+}
+function resolvePackageRoot() {
+  const override = process.env.MYCO_TEAM_PACKAGE_ROOT?.trim();
+  if (override) return override;
+  return path4.resolve(path4.dirname(fileURLToPath(import.meta.url)), "..");
+}
+function getTeamPackageVersion() {
+  if (true) {
+    return "0.1.1";
+  }
+  const packageRoot = resolvePackageRoot();
+  const candidatePaths = [
+    path4.join(packageRoot, "package.json"),
+    path4.join(path4.resolve(path4.dirname(fileURLToPath(import.meta.url)), ".."), "package.json")
+  ];
+  for (const candidatePath of candidatePaths) {
+    if (!fs4.existsSync(candidatePath)) continue;
+    const packageJson = JSON.parse(fs4.readFileSync(candidatePath, "utf-8"));
+    if (packageJson.version) return packageJson.version;
+  }
+  return "0.1.0";
+}
+function getMycoSchemaVersion() {
+  return String(SCHEMA_VERSION);
+}
+function resolveLocalConfigPath(vaultDir) {
+  return resolveVaultConfigPath(vaultDir, TEAM_STATE_DIR, TEAM_CONFIG_FILE);
+}
+function resolveLegacyLocalConfigPath() {
+  return resolveHomeConfigPath(LEGACY_TEAM_CONFIG_DIR, TEAM_CONFIG_FILE);
+}
+function resolveDeployDir(vaultDir) {
+  return path4.join(vaultDir, TEAM_STATE_DIR, TEAM_DEPLOY_DIR);
+}
+function resolveLegacyDeployDir(vaultDir) {
+  return path4.join(vaultDir, LEGACY_TEAM_DEPLOY_DIR);
+}
+function writeLocalConfig(vaultDir, config) {
+  writeJsonConfig(resolveLocalConfigPath(vaultDir), config);
+}
+function migrateLegacyDeployDir(vaultDir) {
+  const legacyDeployDir = resolveLegacyDeployDir(vaultDir);
+  const nextDeployDir = resolveDeployDir(vaultDir);
+  if (!fs4.existsSync(legacyDeployDir) || fs4.existsSync(nextDeployDir)) return;
+  fs4.mkdirSync(path4.dirname(nextDeployDir), { recursive: true });
+  fs4.renameSync(legacyDeployDir, nextDeployDir);
+}
+function readLocalConfig(vaultDir) {
+  const config = readJsonConfig(resolveLocalConfigPath(vaultDir));
+  if (config) {
+    migrateLegacyDeployDir(vaultDir);
+    return config;
+  }
+  const legacyConfig = readJsonConfig(resolveLegacyLocalConfigPath());
+  if (!legacyConfig) return null;
+  if (legacyConfig.vault_dir && legacyConfig.vault_dir !== vaultDir) return null;
+  const migrated = {
+    worker_name: legacyConfig.worker_name,
+    worker_url: legacyConfig.worker_url,
+    package_version: legacyConfig.package_version,
+    created_at: legacyConfig.created_at,
+    last_upgraded: legacyConfig.last_upgraded,
+    config_version: legacyConfig.config_version ?? TEAM_CONFIG_VERSION
+  };
+  writeLocalConfig(vaultDir, migrated);
+  if (legacyConfig.api_key) writeSecret(vaultDir, TEAM_API_KEY_SECRET, legacyConfig.api_key);
+  if (legacyConfig.mcp_token) writeSecret(vaultDir, TEAM_MCP_TOKEN_SECRET, legacyConfig.mcp_token);
+  migrateLegacyDeployDir(vaultDir);
+  return migrated;
+}
+function wrangler(args, options) {
+  return runWrangler(args, { cwd: options?.cwd, timeoutMs: WRANGLER_COMMAND_TIMEOUT_MS });
+}
+function locateWorkerSource() {
+  const root = resolvePackageRoot();
+  const distPath = path4.join(root, "dist", WORKER_SOURCE_DIR);
+  if (fs4.existsSync(distPath)) return distPath;
+  const srcPath = path4.join(root, WORKER_SOURCE_DIR);
+  if (fs4.existsSync(srcPath)) return srcPath;
+  throw new Error(`Cannot find ${WORKER_SOURCE_DIR} \u2014 are you running from the myco-team package?`);
+}
+function prepareDeployDir(vaultDir, d1Id, kvId) {
+  const srcDir = locateWorkerSource();
+  const deployDir = resolveDeployDir(vaultDir);
+  const name = resourceName(vaultDir);
+  return stageDeploymentDir({
+    sourceDir: srcDir,
+    deployDir,
+    reset: true,
+    textPatches: [{
+      filePath: "wrangler.toml",
+      transforms: [
+        (toml) => toml.replace(TOML_NAME_REGEX, `name = "${name}"`),
+        (toml) => toml.replace(TOML_D1_PLACEHOLDER_REGEX, d1Id),
+        (toml) => toml.replace(TOML_DB_NAME_REGEX, `database_name = "${name}"`),
+        (toml) => toml.replace(TOML_INDEX_NAME_REGEX, `index_name = "${name}-vectors"`),
+        (toml) => toml.replace(TOML_KV_PLACEHOLDER_REGEX, kvId),
+        (toml) => toml.replace(TOML_TEAM_PACKAGE_VERSION_REGEX, `MYCO_TEAM_PACKAGE_VERSION = "${getTeamPackageVersion()}"`),
+        (toml) => toml.replace(TOML_MYCO_SCHEMA_VERSION_REGEX, `MYCO_SCHEMA_VERSION = "${getMycoSchemaVersion()}"`)
+      ]
+    }],
+    installDepsTimeoutMs: WRANGLER_COMMAND_TIMEOUT_MS * 3
+  });
+}
+function ensureKvNamespace(name) {
+  const kvName = `${name}-secrets`;
+  const lookupExisting = () => {
+    const listOutput = wrangler(["kv", "namespace", "list"]);
+    const namespaces = extractJsonArray(listOutput);
+    const normalize = (s) => s.replace(/[-_]/g, "");
+    const target = normalize(kvName);
+    const existing = namespaces.find((ns) => normalize(ns.title) === target || normalize(ns.title).endsWith(target));
+    if (!existing) throw new Error(`KV namespace "${kvName}" not found in list of ${namespaces.length} namespaces`);
+    return existing.id;
+  };
+  try {
+    const output = wrangler(["kv", "namespace", "create", kvName]);
+    return parseKvNamespaceId(output);
+  } catch (err) {
+    const errMsg = err.message;
+    if (errMsg.includes("already exists") || errMsg.includes("duplicate") || errMsg.includes("same title")) {
+      return lookupExisting();
+    }
+    throw err;
+  }
+}
+async function rotateMcpTokenForWorker(workerUrl, apiKey) {
+  const response = await fetch(`${workerUrl}/mcp/rotate`, {
+    method: "POST",
+    headers: {
+      Authorization: `Bearer ${apiKey}`,
+      "Content-Type": "application/json"
+    }
+  });
+  if (!response.ok) {
+    throw new Error(`MCP token rotation failed: ${response.status} ${await response.text()}`);
+  }
+  const body = await response.json();
+  if (!body.token) {
+    throw new Error("MCP token rotation response did not include a token");
+  }
+  return body.token;
+}
+async function teamInit(vaultDir) {
+  console.log("Provisioning team sync infrastructure...\n");
+  try {
+    const version = wrangler(["--version"]).trim();
+    console.log(`wrangler: ${version}`);
+  } catch {
+    console.error("Error: wrangler CLI not found. Install it with: npm install -g wrangler");
+    process.exit(1);
+  }
+  try {
+    wrangler(["whoami"]);
+    console.log("Cloudflare auth: OK\n");
+  } catch {
+    console.error("Error: Not authenticated with Cloudflare. Run: wrangler login");
+    process.exit(1);
+  }
+  const name = resourceName(vaultDir);
+  console.log(`Resource name: ${name}
+`);
+  console.log("Creating D1 database...");
+  let d1Id;
+  try {
+    const d1Output = wrangler(["d1", "create", name]);
+    d1Id = parseD1Id(d1Output);
+    console.log(`D1 database created: ${d1Id}
+`);
+  } catch (err) {
+    const errMsg = err.message;
+    if (errMsg.includes("already exists")) {
+      console.log("D1 database already exists, looking up ID...");
+      const listOutput = wrangler(["d1", "list", "--json"]);
+      const databases = JSON.parse(listOutput);
+      const existing = databases.find((db) => db.name === name);
+      if (!existing) {
+        console.error(`D1 database "${name}" reported as existing but not found in list`);
+        process.exit(1);
+      }
+      d1Id = existing.uuid;
+      console.log(`Reusing D1 database: ${d1Id}
+`);
+    } else {
+      console.error(`Failed to create D1 database: ${errMsg}`);
+      process.exit(1);
+    }
+  }
+  console.log("Creating Vectorize index...");
+  try {
+    wrangler(["vectorize", "create", `${name}-vectors`, "--dimensions", VECTORIZE_DIMENSIONS, "--metric", VECTORIZE_METRIC]);
+    console.log("Vectorize index created\n");
+  } catch (err) {
+    const errMsg = err.message;
+    if (errMsg.includes("already exists") || errMsg.includes("duplicate_name")) {
+      console.log("Vectorize index already exists, reusing\n");
+    } else {
+      console.error(`Failed to create Vectorize index: ${errMsg}`);
+      process.exit(1);
+    }
+  }
+  console.log("Creating KV namespace for secrets...");
+  let kvId;
+  try {
+    kvId = ensureKvNamespace(name);
+    console.log(`KV namespace ready: ${kvId}
+`);
+  } catch (err) {
+    console.error(`Failed to create KV namespace: ${err.message}`);
+    process.exit(1);
+  }
+  const apiKey = crypto2.randomBytes(API_KEY_BYTES).toString("hex");
+  console.log("Preparing worker deployment...");
+  const deployDir = prepareDeployDir(vaultDir, d1Id, kvId);
+  console.log("Setting API key secret...");
+  try {
+    runWrangler(["secret", "put", TEAM_API_KEY_SECRET, "--name", name], {
+      cwd: deployDir,
+      input: apiKey,
+      timeoutMs: WRANGLER_COMMAND_TIMEOUT_MS
+    });
+    console.log("Secret set\n");
+  } catch (err) {
+    console.error(`Failed to set API key secret: ${err.message}`);
+    process.exit(1);
+  }
+  console.log("Deploying worker...");
+  let workerUrl;
+  try {
+    const deployOutput = wrangler(["deploy"], { cwd: deployDir });
+    workerUrl = parseWorkerUrl(deployOutput);
+    console.log(`Worker deployed: ${workerUrl}
+`);
+  } catch (err) {
+    console.error(`Failed to deploy worker: ${err.message}`);
+    process.exit(1);
+  }
+  console.log("Setting team configuration...");
+  try {
+    const { getMachineId } = await import("./machine-id-RCM7TXPJ.js");
+    const creatorMachineId = await getMachineId(vaultDir);
+    await fetch(`${workerUrl}/config`, {
+      method: "PUT",
+      headers: { "Authorization": `Bearer ${apiKey}`, "Content-Type": "application/json" },
+      body: JSON.stringify({
+        team_name: name,
+        embedding_model: "@cf/baai/bge-m3",
+        embedding_dimensions: "1024",
+        created_at: String(Math.floor(Date.now() / 1e3)),
+        created_by: creatorMachineId
+      })
+    });
+    console.log("Team config saved\n");
+  } catch {
+    console.log("Warning: could not seed team config (non-fatal)\n");
+  }
+  let mcpToken = null;
+  try {
+    mcpToken = await rotateMcpTokenForWorker(workerUrl, apiKey);
+  } catch {
+  }
+  updateTeamConfig(vaultDir, {
+    enabled: true,
+    worker_url: workerUrl
+  });
+  writeSecret(vaultDir, TEAM_API_KEY_SECRET, apiKey);
+  if (mcpToken) writeSecret(vaultDir, TEAM_MCP_TOKEN_SECRET, mcpToken);
+  writeLocalConfig(vaultDir, {
+    worker_name: name,
+    worker_url: workerUrl,
+    package_version: getTeamPackageVersion(),
+    created_at: (/* @__PURE__ */ new Date()).toISOString(),
+    last_upgraded: (/* @__PURE__ */ new Date()).toISOString(),
+    config_version: TEAM_CONFIG_VERSION
+  });
+  console.log("Team sync configured!\n");
+  console.log(`  URL:     ${workerUrl}`);
+  console.log(`  API Key: ${apiKey.slice(0, 8)}...${apiKey.slice(-4)}`);
+  if (mcpToken) {
+    console.log(`  MCP:     ${mcpToken.slice(0, 8)}...${mcpToken.slice(-4)}`);
+  }
+  console.log("\nShare the URL and API key with teammates so they can connect.");
+}
+function upgradeWorker(vaultDir) {
+  const config = loadConfig(vaultDir);
+  if (!config.team.worker_url) {
+    return { success: false, error: "No team sync configured. Run: myco team init" };
+  }
+  migrateLegacyDeployDir(vaultDir);
+  const deployDir = resolveDeployDir(vaultDir);
+  const tomlPath = path4.join(deployDir, "wrangler.toml");
+  if (!fs4.existsSync(tomlPath)) {
+    return { success: false, error: "No deployment directory found. Run: myco team init" };
+  }
+  const existingToml = fs4.readFileSync(tomlPath, "utf-8");
+  const d1Match = existingToml.match(TOML_DB_ID_REGEX);
+  if (!d1Match || d1Match[1] === "<YOUR_D1_DATABASE_ID>") {
+    return { success: false, error: "Cannot determine D1 database ID from existing deployment. Run: myco team init" };
+  }
+  const d1Id = d1Match[1];
+  const nameMatch = existingToml.match(/^name\s*=\s*"([^"]*)"/m);
+  const dbNameMatch = existingToml.match(/database_name\s*=\s*"([^"]*)"/);
+  const indexNameMatch = existingToml.match(/index_name\s*=\s*"([^"]*)"/);
+  const workerName = nameMatch?.[1] ?? resourceName(vaultDir);
+  const kvMatch = existingToml.match(TOML_KV_ID_REGEX);
+  let kvId;
+  if (kvMatch) {
+    kvId = kvMatch[1];
+  } else {
+    try {
+      kvId = ensureKvNamespace(workerName);
+    } catch (err) {
+      return { success: false, error: `Failed to provision KV namespace: ${err.message}` };
+    }
+  }
+  try {
+    stageDeploymentDir({
+      sourceDir: locateWorkerSource(),
+      deployDir,
+      textPatches: [{
+        filePath: "wrangler.toml",
+        transforms: [
+          (toml) => toml.replace(TOML_NAME_REGEX, `name = "${workerName}"`),
+          (toml) => toml.replace(TOML_D1_PLACEHOLDER_REGEX, d1Id),
+          (toml) => toml.replace(TOML_DB_NAME_REGEX, `database_name = "${dbNameMatch?.[1] ?? workerName}"`),
+          (toml) => toml.replace(TOML_INDEX_NAME_REGEX, `index_name = "${indexNameMatch?.[1] ?? `${workerName}-vectors`}"`),
+          (toml) => toml.replace(TOML_KV_PLACEHOLDER_REGEX, kvId),
+          (toml) => toml.replace(TOML_TEAM_PACKAGE_VERSION_REGEX, `MYCO_TEAM_PACKAGE_VERSION = "${getTeamPackageVersion()}"`),
+          (toml) => toml.replace(TOML_MYCO_SCHEMA_VERSION_REGEX, `MYCO_SCHEMA_VERSION = "${getMycoSchemaVersion()}"`)
+        ]
+      }],
+      installDepsTimeoutMs: WRANGLER_COMMAND_TIMEOUT_MS * 3
+    });
+  } catch (err) {
+    return { success: false, error: `Failed to install worker dependencies: ${err.message}` };
+  }
+  const secrets = readSecrets(vaultDir);
+  const apiKey = secrets[TEAM_API_KEY_SECRET];
+  if (apiKey) {
+    try {
+      runWrangler(["secret", "put", TEAM_API_KEY_SECRET, "--name", workerName], {
+        cwd: deployDir,
+        input: apiKey,
+        timeoutMs: WRANGLER_COMMAND_TIMEOUT_MS
+      });
+    } catch {
+    }
+  }
+  try {
+    const deployOutput = wrangler(["deploy"], { cwd: deployDir });
+    const workerUrl = parseWorkerUrl(deployOutput);
+    const version = getTeamPackageVersion();
+    updateTeamConfig(vaultDir, {
+      worker_url: workerUrl
+    });
+    const localConfig = readLocalConfig(vaultDir);
+    if (localConfig) {
+      writeLocalConfig(vaultDir, {
+        ...localConfig,
+        worker_name: workerName,
+        worker_url: workerUrl,
+        package_version: version,
+        last_upgraded: (/* @__PURE__ */ new Date()).toISOString()
+      });
+    }
+    return { success: true, worker_url: workerUrl, version };
+  } catch (err) {
+    return { success: false, error: `Failed to deploy worker: ${err.message}` };
+  }
+}
+async function teamUpgrade(vaultDir) {
+  console.log("Upgrading team sync worker...\n");
+  const result = upgradeWorker(vaultDir);
+  if (!result.success) {
+    console.error(result.error);
+    process.exit(1);
+  }
+  console.log(`Worker deployed: ${result.worker_url}`);
+  console.log(`Version: ${result.version}`);
+  console.log("\nUpgrade complete.");
+}
+
+export {
+  readSecrets,
+  writeSecret,
+  loadSecrets,
+  resolveVaultConfigPath,
+  readJsonConfig,
+  getTeamPackageVersion,
+  teamInit,
+  upgradeWorker,
+  teamUpgrade
+};
+//# sourceMappingURL=chunk-CDM6ZLMZ.js.map