@vendian/cli 0.0.5 → 0.0.7

package/README.md

@@ -6,6 +6,8 @@ Command-line tools for signing in to Vendian and running local agent workflows.
 npm install -g @vendian/cli
 vendian
 vendian login
+vendian init --output-dir ./agents
+vendian create "My Agent" --output-dir ./agents
 vendian cloud local serve --agents-dir ./agents
 ```
 
@@ -16,6 +18,11 @@ vendian
 vendian login
 vendian doctor
 vendian update
+vendian init --output-dir ./agents
+vendian create "My Agent" --output-dir ./agents
+vendian validate ./agents/my-agent --runtime
+vendian test ./agents/my-agent --dry-run --mock-credentials
+vendian models
 vendian cloud local serve --agents-dir ./agents
 ```
 
@@ -32,6 +39,13 @@ managed runtime without changing your agents.
 After login, regular `vendian cloud ...` commands are forwarded to the managed
 runtime installed by the CLI.
 
+Agent authoring commands are also forwarded to the managed Python SDK CLI.
+`vendian init` writes the current SDK-owned authoring docs into `.vendian-docs/`,
+and `vendian create` scaffolds agents from the SDK templates. Updating the
+managed runtime refreshes these docs and templates with the Python SDK. The CLI
+remembers workspaces initialized with `vendian init` and refreshes their
+`.vendian-docs/` automatically after `vendian update` or a managed auto-update.
+
 ## Local Data
 
 Vendian stores its managed runtime and CLI state under your user profile:

package/cli-wrapper.cjs

@@ -52,15 +52,21 @@ var import_node_path = __toESM(require("node:path"), 1);
 function pathApi(platform) {
   return platform === "win32" ? import_node_path.default.win32 : import_node_path.default.posix;
 }
+function homeDir(env, platform) {
+  if (platform === "win32") {
+    return env.USERPROFILE || import_node_os.default.homedir();
+  }
+  return env.HOME || import_node_os.default.homedir();
+}
 function vendianHome(env = process.env, platform = process.platform) {
   if (env.VENDIAN_CLI_HOME) {
     return pathApi(platform).resolve(env.VENDIAN_CLI_HOME);
   }
   if (platform === "win32") {
-    const root = env.LOCALAPPDATA || import_node_path.default.join(import_node_os.default.homedir(), "AppData", "Local");
+    const root = env.LOCALAPPDATA || import_node_path.default.win32.join(homeDir(env, platform), "AppData", "Local");
     return import_node_path.default.win32.join(root, "Vendian", "cli");
   }
-  return import_node_path.default.posix.join(import_node_os.default.homedir(), ".vendian", "cli");
+  return import_node_path.default.posix.join(homeDir(env, platform), ".vendian", "cli");
 }
 function configPath(env = process.env, platform = process.platform) {
   if (env.VENDIAN_CLI_CONFIG) {
@@ -239,12 +245,10 @@ function run(command, args, options = {}) {
     ...options
   });
 }
-function savePackageTokenSecret(token, config = {}, platform = process.platform) {
-  if (!token) {
-    return { ok: false };
-  }
-  if (platform === "darwin") {
-    const result = run("security", [
+function buildMacKeychainSaveCommand(token) {
+  return [
+    "security",
+    [
       "add-generic-password",
       "-a",
       PACKAGE_TOKEN_ACCOUNT,
@@ -253,7 +257,28 @@ function savePackageTokenSecret(token, config = {}, platform = process.platform)
       "-w",
       token,
       "-U"
-    ]);
+    ]
+  ];
+}
+function buildMacKeychainLoadCommand() {
+  return [
+    "security",
+    [
+      "find-generic-password",
+      "-a",
+      PACKAGE_TOKEN_ACCOUNT,
+      "-s",
+      SERVICE,
+      "-w"
+    ]
+  ];
+}
+function savePackageTokenSecret(token, config = {}, platform = process.platform) {
+  if (!token) {
+    return { ok: false };
+  }
+  if (platform === "darwin") {
+    const result = run(...buildMacKeychainSaveCommand(token));
     return { ok: result.status === 0, provider: "macos-keychain" };
   }
   if (platform === "win32") {
@@ -286,14 +311,7 @@ function savePackageTokenSecret(token, config = {}, platform = process.platform)
 }
 function loadPackageTokenSecret(config = {}, platform = process.platform) {
   if (platform === "darwin") {
-    const result = run("security", [
-      "find-generic-password",
-      "-a",
-      PACKAGE_TOKEN_ACCOUNT,
-      "-s",
-      SERVICE,
-      "-w"
-    ]);
+    const result = run(...buildMacKeychainLoadCommand());
     return result.status === 0 ? result.stdout.trim() : "";
   }
   if (platform === "win32") {
@@ -417,45 +435,96 @@ function doctor({ env = process.env, platform = process.platform } = {}) {
 }
 
 // src/forward.js
+var import_node_fs8 = __toESM(require("node:fs"), 1);
+
+// src/docs.js
 var import_node_fs5 = __toESM(require("node:fs"), 1);
-var AUTO_UPDATE_INTERVAL_MS = 24 * 60 * 60 * 1e3;
-async function forwardToPythonVendian(args, { env = process.env, platform = process.platform } = {}) {
-  const venvPath = managedVenvPath(env, platform);
-  const vendianPath = venvVendian(venvPath, platform);
-  if (!import_node_fs5.default.existsSync(vendianPath)) {
-    throw new Error("Vendian is not set up yet. Run `vendian login` first.");
-  }
-  maybeAutoUpdateManagedEnv({ env, platform, venvPath });
-  const code = await spawnForward(vendianPath, args, { env });
-  process.exitCode = code;
+var import_node_path4 = __toESM(require("node:path"), 1);
+var DOC_WORKSPACES_KEY = "agentDocWorkspaces";
+function pathApi2(platform) {
+  return platform === "win32" ? import_node_path4.default.win32 : import_node_path4.default.posix;
 }
-function maybeAutoUpdateManagedEnv({ env = process.env, platform = process.platform, venvPath = managedVenvPath(env, platform) } = {}) {
-  if (env.VENDIAN_SKIP_AUTO_UPDATE === "1") {
-    return false;
+function commandWritesAgentDocs(args = []) {
+  return args[0] === "init";
+}
+function initOutputDir(args = []) {
+  for (let index = 1; index < args.length; index += 1) {
+    const arg = args[index];
+    if (arg === "--output-dir" || arg === "-o") {
+      return args[index + 1] || ".";
+    }
+    if (arg.startsWith("--output-dir=")) {
+      return arg.slice("--output-dir=".length) || ".";
+    }
   }
+  return ".";
+}
+function resolveWorkspacePath(outputDir, { cwd = process.cwd(), platform = process.platform } = {}) {
+  const api = pathApi2(platform);
+  const raw = outputDir || ".";
+  return api.isAbsolute(raw) ? api.normalize(raw) : api.resolve(cwd, raw);
+}
+function recordAgentDocsWorkspace(outputDir, {
+  env = process.env,
+  platform = process.platform,
+  cwd = process.cwd(),
+  now = /* @__PURE__ */ new Date()
+} = {}) {
+  const workspacePath = resolveWorkspacePath(outputDir, { cwd, platform });
   const config = loadConfig(env, platform);
-  const lastUpdate = Date.parse(config.lastManagedUpdateAt || "");
-  if (Number.isFinite(lastUpdate) && Date.now() - lastUpdate < AUTO_UPDATE_INTERVAL_MS) {
-    return false;
-  }
-  const registry = registryConfig(config, env);
-  if (!registry.token) {
+  const existing = Array.isArray(config[DOC_WORKSPACES_KEY]) ? config[DOC_WORKSPACES_KEY] : [];
+  const workspaces = [workspacePath, ...existing.filter((entry) => entry !== workspacePath)];
+  const next = {
+    ...config,
+    [DOC_WORKSPACES_KEY]: workspaces,
+    lastAgentDocsInitAt: now.toISOString()
+  };
+  saveConfig(next, env, platform);
+  return next;
+}
+function recordForwardedDocsCommand(args, code, options = {}) {
+  if (code !== 0 || !commandWritesAgentDocs(args)) {
     return false;
   }
-  const pythonPath = venvPython(venvPath, platform);
-  if (!import_node_fs5.default.existsSync(pythonPath)) {
-    return false;
+  recordAgentDocsWorkspace(initOutputDir(args), options);
+  return true;
+}
+function refreshAgentDocsWorkspaces({
+  config,
+  venvPath,
+  env = process.env,
+  platform = process.platform,
+  run: run2 = runInherit,
+  now = /* @__PURE__ */ new Date()
+} = {}) {
+  const currentConfig = config || loadConfig(env, platform);
+  const workspaces = Array.isArray(currentConfig[DOC_WORKSPACES_KEY]) ? [...new Set(currentConfig[DOC_WORKSPACES_KEY].filter((entry) => typeof entry === "string" && entry.trim()))] : [];
+  if (workspaces.length === 0) {
+    saveConfig(currentConfig, env, platform);
+    return { config: currentConfig, refreshed: 0, failed: 0 };
   }
-  try {
-    console.error("[vendian] Checking managed CLI/runtime updates...");
-    installVendianPackages({ pythonPath, venvPath, config, env });
-    saveConfig({ ...config, lastManagedUpdateAt: (/* @__PURE__ */ new Date()).toISOString() }, env, platform);
-    return true;
-  } catch (error) {
-    const message = error && typeof error.message === "string" ? error.message : String(error);
-    console.error(`[vendian] Update check failed; continuing with installed CLI. ${message}`);
-    return false;
+  const vendianPath = venvVendian(venvPath, platform);
+  let refreshed = 0;
+  let failed = 0;
+  for (const workspace of workspaces) {
+    if (!import_node_fs5.default.existsSync(workspace)) {
+      continue;
+    }
+    const status = run2(vendianPath, ["init", "--output-dir", workspace, "--yes"]);
+    if (status === 0) {
+      refreshed += 1;
+    } else {
+      failed += 1;
+      console.error(`[vendian] Could not refresh SDK docs in ${workspace}`);
+    }
   }
+  const next = {
+    ...currentConfig,
+    [DOC_WORKSPACES_KEY]: workspaces,
+    lastAgentDocsRefreshAt: now.toISOString()
+  };
+  saveConfig(next, env, platform);
+  return { config: next, refreshed, failed };
 }
 
 // src/setup.js
@@ -465,7 +534,7 @@ var import_node_fs7 = __toESM(require("node:fs"), 1);
 var import_node_crypto = __toESM(require("node:crypto"), 1);
 var import_node_http = __toESM(require("node:http"), 1);
 var import_node_fs6 = __toESM(require("node:fs"), 1);
-var import_node_path4 = __toESM(require("node:path"), 1);
+var import_node_path5 = __toESM(require("node:path"), 1);
 var import_node_child_process3 = require("node:child_process");
 var DEFAULT_OAUTH_REDIRECT_PORT = 8765;
 function resolveApiUrl({ backend, apiUrl, env = process.env } = {}) {
@@ -509,6 +578,15 @@ async function loginWithVendianOAuth({ backend, apiUrl, noBrowser = false, env =
     await callback.close();
   }
 }
+async function fetchPackageCredentials({ apiUrl, accessToken }) {
+  if (!apiUrl || !accessToken) {
+    return void 0;
+  }
+  const payload = await getJson(`${String(apiUrl).replace(/\/$/, "")}/api/v1/cli/package-credentials`, {
+    Authorization: `Bearer ${accessToken}`
+  });
+  return payload.packageCredentials;
+}
 function loadCloudConfig(env = process.env, platform = process.platform) {
   const file = cloudConfigPath(env, platform);
   try {
@@ -533,6 +611,21 @@ function cloudAuthStatus({ backend, apiUrl, env = process.env, platform = proces
     profiles
   };
 }
+function activeCloudAuthStatus({ env = process.env, platform = process.platform } = {}) {
+  const config = loadCloudConfig(env, platform);
+  const profiles = config.profiles && typeof config.profiles === "object" ? config.profiles : {};
+  const apiUrl = typeof config.active_api_url === "string" ? config.active_api_url : void 0;
+  const profile = apiUrl ? profiles[apiUrl] : void 0;
+  return {
+    apiUrl,
+    activeApiUrl: apiUrl,
+    profile: profile && typeof profile === "object" ? profile : void 0,
+    authenticated: Boolean(profile?.access_token),
+    email: typeof profile?.email === "string" ? profile.email : void 0,
+    expiresAt: typeof profile?.expires_at === "string" ? profile.expires_at : void 0,
+    profiles
+  };
+}
 async function getOAuthConfig(apiUrl, redirectUri) {
   const url = new URL(`${apiUrl}/api/v1/cli/auth/oauth/config`);
   url.searchParams.set("redirectUri", redirectUri);
@@ -564,8 +657,8 @@ async function exchangeCodeForClerkToken(config, code, codeVerifier, redirectUri
   }
   return String(token);
 }
-async function getJson(url) {
-  const response = await fetch(url, { headers: { Accept: "application/json" } });
+async function getJson(url, headers = {}) {
+  const response = await fetch(url, { headers: { Accept: "application/json", ...headers } });
   return decodeResponse(response);
 }
 async function postJson(url, body) {
@@ -655,24 +748,30 @@ function openBrowser(url) {
     return;
   }
   if (platform === "darwin") {
-    (0, import_node_child_process3.spawnSync)("open", [url], { stdio: "ignore", shell: false });
+    (0, import_node_child_process3.spawnSync)(...buildMacOpenCommand(url), { stdio: "ignore", shell: false });
     return;
   }
-  (0, import_node_child_process3.spawnSync)("xdg-open", [url], { stdio: "ignore", shell: false });
+  (0, import_node_child_process3.spawnSync)(...buildLinuxOpenCommand(url), { stdio: "ignore", shell: false });
 }
 function buildWindowsOpenCommand(url) {
   return ["rundll32.exe", ["url.dll,FileProtocolHandler", String(url)]];
 }
+function buildMacOpenCommand(url) {
+  return ["open", [String(url)]];
+}
+function buildLinuxOpenCommand(url) {
+  return ["xdg-open", [String(url)]];
+}
 function cloudConfigPath(env = process.env, platform = process.platform) {
   if (env.VENDIAN_CLOUD_CONFIG) {
-    return import_node_path4.default.resolve(env.VENDIAN_CLOUD_CONFIG);
+    return import_node_path5.default.resolve(env.VENDIAN_CLOUD_CONFIG);
   }
   if (platform === "win32") {
-    const root2 = env.APPDATA || import_node_path4.default.join(process.env.USERPROFILE || "", "AppData", "Roaming");
-    return import_node_path4.default.win32.join(root2, "Vendian", "cloud-auth.json");
+    const root2 = env.APPDATA || import_node_path5.default.join(process.env.USERPROFILE || "", "AppData", "Roaming");
+    return import_node_path5.default.win32.join(root2, "Vendian", "cloud-auth.json");
   }
-  const root = env.XDG_CONFIG_HOME || import_node_path4.default.join(process.env.HOME || "", ".config");
-  return import_node_path4.default.posix.join(root, "vendian", "cloud-auth.json");
+  const root = env.XDG_CONFIG_HOME || import_node_path5.default.join(process.env.HOME || "", ".config");
+  return import_node_path5.default.posix.join(root, "vendian", "cloud-auth.json");
 }
 function saveCloudToken(token, { env = process.env, platform = process.platform } = {}) {
   const file = cloudConfigPath(env, platform);
@@ -694,7 +793,7 @@ function saveCloudToken(token, { env = process.env, platform = process.platform
     scopes: token.scopes,
     tooling_eligible: token.toolingEligible
   };
-  import_node_fs6.default.mkdirSync(import_node_path4.default.dirname(file), { recursive: true });
+  import_node_fs6.default.mkdirSync(import_node_path5.default.dirname(file), { recursive: true });
   import_node_fs6.default.writeFileSync(file, `${JSON.stringify(raw, null, 2)}
 `, { encoding: "utf8", mode: 384 });
   try {
@@ -739,24 +838,12 @@ async function setup({
       throw new Error("Vendian login succeeded, but the backend did not return package credentials. Configure CLI_PACKAGE_REGISTRY_TOKEN on the backend.");
     }
     if (packageCredentials) {
-      next.gitlabHost = packageCredentials.gitlabHost || next.gitlabHost;
-      next.gitlabUsername = packageCredentials.username || next.gitlabUsername;
-      next.sdkPublicProjectId = packageCredentials.sdkProjectId || next.sdkPublicProjectId;
-      next.sdkRuntimeProjectId = packageCredentials.runtimeProjectId || next.sdkRuntimeProjectId;
-      next.vendianAgentsVersion = packageCredentials.vendianAgentsVersion || next.vendianAgentsVersion;
-      next.vendianAgentsRuntimeVersion = packageCredentials.vendianAgentsRuntimeVersion || next.vendianAgentsRuntimeVersion;
-      const secret = savePackageTokenSecret(packageCredentials.token, next, platform);
-      if (secret.ok) {
-        Object.assign(next, secret.config || {});
-        delete next.gitlabToken;
-        console.log("Package access saved.");
-      } else {
-        next.gitlabToken = packageCredentials.token;
-        console.log("Package access saved in the local Vendian CLI config file.");
-      }
+      savePackageCredentials(next, packageCredentials, { platform });
     }
   } else if (auth.authenticated) {
     console.log(`Cloud authentication already saved for ${auth.apiUrl}${auth.email ? ` (${auth.email})` : ""}.`);
+    const refreshed = await refreshPackageAccessFromCloudAuth({ config: next, auth, env, platform });
+    Object.assign(next, refreshed.config);
   } else if (registry.token) {
     if (registry.tokenSource !== "secret-store") {
       next.gitlabToken = registry.token;
@@ -777,7 +864,8 @@ async function setup({
   console.log(`Python: ${pythonVersion(pythonPath) || pythonPath}`);
   saveConfig(next, env, platform);
   installVendianPackages({ pythonPath, venvPath, config: next, env, platform });
-  saveConfig({ ...next, lastManagedUpdateAt: (/* @__PURE__ */ new Date()).toISOString() }, env, platform);
+  const updated = { ...next, lastManagedUpdateAt: (/* @__PURE__ */ new Date()).toISOString() };
+  refreshAgentDocsWorkspaces({ config: updated, venvPath, env, platform });
   if (!verifyVendianImports(pythonPath)) {
     throw new Error("Vendian packages installed, but import verification failed.");
   }
@@ -790,6 +878,57 @@ async function setup({
     console.log(line);
   }
 }
+function savePackageCredentials(config, packageCredentials, { platform = process.platform } = {}) {
+  if (!packageCredentials?.token) {
+    return false;
+  }
+  config.gitlabHost = packageCredentials.gitlabHost || config.gitlabHost;
+  config.gitlabUsername = packageCredentials.username || config.gitlabUsername;
+  config.sdkPublicProjectId = packageCredentials.sdkProjectId || config.sdkPublicProjectId;
+  config.sdkRuntimeProjectId = packageCredentials.runtimeProjectId || config.sdkRuntimeProjectId;
+  config.vendianAgentsVersion = packageCredentials.vendianAgentsVersion || config.vendianAgentsVersion;
+  config.vendianAgentsRuntimeVersion = packageCredentials.vendianAgentsRuntimeVersion || config.vendianAgentsRuntimeVersion;
+  const secret = savePackageTokenSecret(packageCredentials.token, config, platform);
+  if (secret.ok) {
+    Object.assign(config, secret.config || {});
+    delete config.gitlabToken;
+    console.log("Package access saved.");
+  } else {
+    config.gitlabToken = packageCredentials.token;
+    console.log("Package access saved in the local Vendian CLI config file.");
+  }
+  return true;
+}
+async function refreshPackageAccessFromCloudAuth({
+  config,
+  auth,
+  env = process.env,
+  platform = process.platform,
+  save = true
+} = {}) {
+  const currentConfig = config || loadConfig(env, platform);
+  const registry = registryConfig(currentConfig, env, platform);
+  if (registry.token) {
+    return { config: currentConfig, refreshed: false };
+  }
+  const status = auth || activeCloudAuthStatus({ env, platform });
+  if (!status.authenticated || !status.apiUrl || !status.profile?.access_token) {
+    return { config: currentConfig, refreshed: false };
+  }
+  const packageCredentials = await fetchPackageCredentials({
+    apiUrl: status.apiUrl,
+    accessToken: status.profile.access_token
+  });
+  if (!packageCredentials?.token) {
+    return { config: currentConfig, refreshed: false };
+  }
+  const next = { ...currentConfig };
+  const stored = savePackageCredentials(next, packageCredentials, { platform });
+  if (stored && save) {
+    saveConfig(next, env, platform);
+  }
+  return { config: next, refreshed: stored };
+}
 function setupCompletionLines({ cloudAuthApiUrl, backend, apiUrl } = {}) {
   const lines = ["Vendian login complete."];
   if (cloudAuthApiUrl) {
@@ -811,13 +950,98 @@ function cloudAuthLoginCommand({ backend, apiUrl } = {}) {
   return "vendian cloud auth login";
 }
 
+// src/forward.js
+var AUTO_UPDATE_INTERVAL_MS = 24 * 60 * 60 * 1e3;
+async function forwardToPythonVendian(args, { env = process.env, platform = process.platform } = {}) {
+  const venvPath = managedVenvPath(env, platform);
+  const vendianPath = venvVendian(venvPath, platform);
+  if (!import_node_fs8.default.existsSync(vendianPath)) {
+    throw new Error("Vendian is not set up yet. Run `vendian login` first.");
+  }
+  const loadedConfig = loadConfig(env, platform);
+  const requiresPackageAccess = commandNeedsPackageAccess(args);
+  const refreshed = requiresPackageAccess ? await refreshPackageAccessFromCloudAuth({ config: loadedConfig, env, platform }) : { config: loadedConfig };
+  maybeAutoUpdateManagedEnv({ env, platform, venvPath });
+  const config = refreshed.config;
+  const registry = registryConfig(config, env, platform);
+  if (requiresPackageAccess && !registry.token) {
+    throw new Error("Package access is missing. Run `vendian login` or `vendian update` before starting local agents.");
+  }
+  const code = await spawnForward(vendianPath, args, {
+    env: {
+      ...env,
+      ...packageIndexEnv(config, env, platform)
+    }
+  });
+  recordForwardedDocsCommand(args, code, { env, platform });
+  process.exitCode = code;
+}
+function commandNeedsPackageAccess(args = []) {
+  return args[0] === "cloud" && args[1] === "local" && ["serve", "run"].includes(args[2]);
+}
+function packageIndexEnv(config = {}, env = process.env, platform = process.platform) {
+  const registry = registryConfig(config, env, platform);
+  const indexes = buildIndexUrls(registry);
+  if (!indexes) {
+    return {};
+  }
+  const extraIndexUrls = joinIndexUrls([
+    indexes.runtimeIndexUrl,
+    "https://pypi.org/simple",
+    env.VENDIAN_PIP_EXTRA_INDEX_URL
+  ]);
+  const uvExtraIndexUrls = joinIndexUrls([
+    indexes.runtimeIndexUrl,
+    "https://pypi.org/simple",
+    env.VENDIAN_UV_EXTRA_INDEX_URL
+  ]);
+  return {
+    VENDIAN_PIP_INDEX_URL: indexes.sdkIndexUrl,
+    VENDIAN_PIP_EXTRA_INDEX_URL: extraIndexUrls,
+    VENDIAN_UV_INDEX_URL: indexes.sdkIndexUrl,
+    VENDIAN_UV_EXTRA_INDEX_URL: uvExtraIndexUrls
+  };
+}
+function joinIndexUrls(urls) {
+  return urls.flatMap((value) => String(value || "").split(/\s+/)).map((value) => value.trim()).filter(Boolean).filter((value, index, all) => all.indexOf(value) === index).join(" ");
+}
+function maybeAutoUpdateManagedEnv({ env = process.env, platform = process.platform, venvPath = managedVenvPath(env, platform) } = {}) {
+  if (env.VENDIAN_SKIP_AUTO_UPDATE === "1") {
+    return false;
+  }
+  const config = loadConfig(env, platform);
+  const lastUpdate = Date.parse(config.lastManagedUpdateAt || "");
+  if (Number.isFinite(lastUpdate) && Date.now() - lastUpdate < AUTO_UPDATE_INTERVAL_MS) {
+    return false;
+  }
+  const registry = registryConfig(config, env);
+  if (!registry.token) {
+    return false;
+  }
+  const pythonPath = venvPython(venvPath, platform);
+  if (!import_node_fs8.default.existsSync(pythonPath)) {
+    return false;
+  }
+  try {
+    console.error("[vendian] Checking managed CLI/runtime updates...");
+    installVendianPackages({ pythonPath, venvPath, config, env });
+    const next = { ...config, lastManagedUpdateAt: (/* @__PURE__ */ new Date()).toISOString() };
+    refreshAgentDocsWorkspaces({ config: next, venvPath, env, platform });
+    return true;
+  } catch (error) {
+    const message = error && typeof error.message === "string" ? error.message : String(error);
+    console.error(`[vendian] Update check failed; continuing with installed CLI. ${message}`);
+    return false;
+  }
+}
+
 // src/tui.js
-var import_node_fs8 = __toESM(require("node:fs"), 1);
+var import_node_fs9 = __toESM(require("node:fs"), 1);
 var import_node_readline = __toESM(require("node:readline"), 1);
 var import_promises = __toESM(require("node:readline/promises"), 1);
 
 // src/version.js
-var CLI_VERSION = true ? "0.0.5" : process.env.npm_package_version || "0.0.0-dev";
+var CLI_VERSION = true ? "0.0.7" : process.env.npm_package_version || "0.0.0-dev";
 
 // src/tui.js
 var RESET = "\x1B[0m";
@@ -839,6 +1063,8 @@ var ENDPOINTS = [
 ];
 var ACTIONS = [
   { id: "connect", label: "Connect / switch endpoint", detail: "Sign in to local, dev, staging, production, or a custom API" },
+  { id: "init", label: "Initialize agent docs", detail: "Write SDK-owned authoring docs into a workspace" },
+  { id: "create", label: "Create agent", detail: "Scaffold a new agent through the Python SDK CLI" },
   { id: "serve", label: "Start local agent server", detail: "Run agents from ./agents through the managed runtime" },
   { id: "doctor", label: "Run doctor", detail: "Check Python, runtime, package access, and local paths" },
   { id: "update", label: "Update managed runtime", detail: "Refresh the Vendian runtime packages" },
@@ -923,7 +1149,7 @@ function runtimeSummary({ env = process.env, platform = process.platform, now =
   const config = loadConfig(env, platform);
   const venvPath = managedVenvPath(env, platform);
   const vendianPath = venvVendian(venvPath, platform);
-  const installed = import_node_fs8.default.existsSync(vendianPath);
+  const installed = import_node_fs9.default.existsSync(vendianPath);
   const lastUpdate = Date.parse(config.lastManagedUpdateAt || "");
   const stale = !Number.isFinite(lastUpdate) || now - lastUpdate > 24 * 60 * 60 * 1e3;
   return {
@@ -937,8 +1163,36 @@ async function runAction(action, { env, platform, input, output }) {
     await connectEndpoint({ env, platform, input, output });
     return false;
   }
+  if (action === "init") {
+    const outputDir = await prompt(input, output, "Workspace directory", ".");
+    output.write(`${CLEAR}${SHOW_CURSOR}`);
+    output.write(`[vendian] Initializing agent docs in ${outputDir || "."}
+
+`);
+    await forwardToPythonVendian(["init", "--output-dir", outputDir || "."], { env, platform });
+    return true;
+  }
+  if (action === "create") {
+    const name = await prompt(input, output, "Agent name");
+    if (!name) {
+      output.write("Agent name is required.\n");
+      await prompt(input, output, "Press Enter to return");
+      return false;
+    }
+    const outputDir = await prompt(input, output, "Output directory", "./agents");
+    output.write(`${CLEAR}${SHOW_CURSOR}`);
+    output.write(`[vendian] Creating agent ${name} in ${outputDir || "./agents"}
+
+`);
+    await forwardToPythonVendian(["create", name, "--output-dir", outputDir || "./agents"], { env, platform });
+    return true;
+  }
   if (action === "serve") {
     const agentsDir = await prompt(input, output, "Agents directory", "./agents");
+    output.write(`${CLEAR}${SHOW_CURSOR}`);
+    output.write(`[vendian] Starting local agent server for ${agentsDir || "./agents"}
+
+`);
     await forwardToPythonVendian(["cloud", "local", "serve", "--agents-dir", agentsDir || "./agents"], { env, platform });
     return true;
   }
@@ -1001,6 +1255,11 @@ function helpText() {
     "Common commands:",
     "  vendian",
     "  vendian login",
+    "  vendian init --output-dir ./agents",
+    '  vendian create "My Agent" --output-dir ./agents',
+    "  vendian validate ./agents/my-agent --runtime",
+    "  vendian test ./agents/my-agent --dry-run --mock-credentials",
+    "  vendian models",
     "  vendian login --backend staging",
     "  vendian login --api-url http://localhost:3000",
     "  vendian cloud local serve --agents-dir ./agents",
@@ -1065,10 +1324,14 @@ Usage:
   vendian setup                 Alias for vendian login
   vendian doctor                Check local bootstrap health
   vendian update                Update the managed Vendian CLI/runtime
-  vendian <command>             Run a Vendian cloud command
+  vendian init                  Write current SDK agent docs into a workspace
+  vendian create "My Agent"     Scaffold a new agent from SDK templates
+  vendian <command>             Run a managed Python SDK/cloud command
 
 Examples:
   vendian login
+  vendian init --output-dir ./agents
+  vendian create "Google Drive Processor" --output-dir ./agents
   vendian login --backend staging
   vendian cloud local serve --agents-dir ./agents
 
@@ -1135,7 +1398,20 @@ function parseSetupOptions(args) {
   return options;
 }
 
+// src/terminal-title.js
+function setTerminalTitle(title, { output = process.stdout, processRef = process } = {}) {
+  const safeTitle = String(title).replace(/[\x00-\x1f\x7f]/g, " ").trim();
+  if (!safeTitle) {
+    return;
+  }
+  processRef.title = safeTitle;
+  if (output?.isTTY && typeof output.write === "function") {
+    output.write(`\x1B]0;${safeTitle}\x07`);
+  }
+}
+
 // src/entry.js
+setTerminalTitle("Vendian CLI");
 main(process.argv.slice(2)).catch((error) => {
   const message = error && typeof error.message === "string" ? error.message : String(error);
   console.error(`[vendian] ${message}`);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vendian/cli",
-  "version": "0.0.5",
+  "version": "0.0.7",
   "description": "Public Vendian CLI bootstrapper and launcher",
   "license": "UNLICENSED",
   "private": false,
@@ -21,7 +21,8 @@
   "scripts": {
     "build": "node scripts/build-package.mjs",
     "prepack": "npm run build",
-    "prepublishOnly": "npm test",
+    "prepublishOnly": "npm run release:sync-version && npm test",
+    "release:sync-version": "node scripts/sync-release-version.mjs",
     "test": "node --test"
   },
   "engines": {