@asiyst/cli 1.0.9 → 1.1.2

package/dist/index.js

@@ -1,46 +1,486 @@
 #!/usr/bin/env node
 
-// src/ui/output.ts
-var ok = (label, detail = "") => console.log(`  \u2713 ${label}${detail ? ` (${detail})` : ""}`);
-var fail = (label, detail = "") => console.log(`  \u2717 ${label}${detail ? `: ${detail}` : ""}`);
-function projectChecks(project) {
-  project.packageJson ? ok("Project detected", typeof project.packageJson.name === "string" ? project.packageJson.name : project.cwd) : fail("Project not detected", "package.json is missing");
-  ok("Framework detected", project.framework);
-  ok("Language detected", project.language);
-  ok("Node.js detected", process.version);
-  ok("Package manager detected", project.packageManager);
-  project.sdkVersion ? ok("@asiyst/sdk detected", project.sdkVersion) : fail("@asiyst/sdk is not installed", "npm install @asiyst/sdk");
-}
-function homeStatus(project, connection = "Not connected") {
-  console.log("\n  PROJECT STATUS");
-  console.log(`    Project          ${typeof project.packageJson?.name === "string" ? project.packageJson.name : "Not detected"}`);
-  console.log(`    Framework        ${project.framework}`);
-  console.log(`    Language         ${project.language}`);
-  console.log(`    Node.js          ${process.version}`);
-  console.log(`    Package Manager  ${project.packageManager}`);
-  console.log(`    @asiyst/sdk      ${project.sdkVersion || "Not installed"}`);
-  console.log("\n  ASIYST STATUS");
-  console.log(`    Connection       ${connection}`);
-  console.log(`    Avatar           Not configured`);
-  console.log(`    AI Provider      Not configured`);
-  console.log(`    Project ID       ${project.config.projectId || "\u2014"}`);
-  if (connection === "Not connected") console.log("\n  Run 'connect' to link this project.");
-}
-function printVerification(results) {
-  console.log("\n  Asiyst Installation Verification\n");
-  for (const result of results) result.ok ? ok(result.name, result.detail) : fail(result.name, result.detail);
-  const success = results.length > 0 && results.every((result) => result.ok);
-  if (success) console.log("\n  \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n\n  ASIYST IS READY \u2713");
-  return success;
+// src/config/ids.ts
+var PROJECT_ID_PATTERN = /^[A-Za-z0-9_][A-Za-z0-9_-]{23}$/;
+var API_KEY_PATTERN = /^[A-Za-z0-9_-]{32}$/;
+var USER_ID_PATTERN = /^[A-Za-z0-9-]{16}$/;
+var AVATAR_ID_PATTERN = /^[A-Za-z0-9]{10}$/;
+function isValidProjectId(value) {
+  return typeof value === "string" && PROJECT_ID_PATTERN.test(value.trim());
+}
+function isValidApiKey(value) {
+  return typeof value === "string" && API_KEY_PATTERN.test(value.trim());
+}
+function isValidUserId(value) {
+  return typeof value === "string" && value.trim() !== "undefined" && value.trim() !== "null" && USER_ID_PATTERN.test(value);
+}
+function isValidAvatarId(value) {
+  return typeof value === "string" && value.trim() !== "undefined" && value.trim() !== "null" && AVATAR_ID_PATTERN.test(value.trim());
+}
+function parseProjectIdArgument(argv = []) {
+  const length = argv.length;
+  for (let index = 0; index < length; index += 1) {
+    const entry = argv[index];
+    if (entry === "--project-id" || entry === "--projectId") {
+      const next = argv[index + 1];
+      return typeof next === "string" ? next : "";
+    }
+    if (entry.startsWith("--project-id=") || entry.startsWith("--projectId=")) {
+      return entry.slice(entry.indexOf("=") + 1);
+    }
+  }
+  return void 0;
+}
+
+// src/api/errors.ts
+var ApiError = class extends Error {
+  constructor(message, status, code = "UNKNOWN") {
+    super(message);
+    this.status = status;
+    this.code = code;
+    this.name = "ApiError";
+  }
+  status;
+  code;
+};
+function errorCodeFromStatus(status, bodyCode) {
+  if (bodyCode === "INVALID_API_KEY") return "INVALID_API_KEY";
+  if (bodyCode === "API_KEY_REVOKED") return "API_KEY_REVOKED";
+  if (bodyCode === "FORBIDDEN") return "FORBIDDEN";
+  if (bodyCode === "USER_MISMATCH") return "USER_MISMATCH";
+  if (bodyCode === "PROJECT_MISMATCH") return "PROJECT_MISMATCH";
+  if (bodyCode === "PROJECT_NOT_FOUND") return "PROJECT_NOT_FOUND";
+  if (bodyCode === "AVATAR_NOT_FOUND") return "AVATAR_NOT_FOUND";
+  if (bodyCode === "AVATAR_ALREADY_IMPORTED") return "AVATAR_ALREADY_IMPORTED";
+  if (bodyCode === "RATE_LIMITED") return "RATE_LIMITED";
+  if (bodyCode === "INTERNAL_ERROR") return "INTERNAL_ERROR";
+  if (status === 401) return "INVALID_API_KEY";
+  if (status === 403) return "FORBIDDEN";
+  if (status === 404) return "NOT_FOUND";
+  if (status === 409) return "CONFLICT";
+  if (status === 400 || status === 422) return "INVALID_REQUEST";
+  if (status === 429) return "RATE_LIMITED";
+  if (status >= 500) return "INTERNAL_ERROR";
+  return "UNKNOWN";
+}
+function friendlyApiMessage(error, endpointUrl) {
+  if (error.code === "INVALID_API_KEY") return "\u2717 Invalid API key.";
+  if (error.code === "API_KEY_REVOKED") {
+    return "\u2717 This API key has been revoked.\nCreate a new key from:\nhttps://asiyst.com";
+  }
+  if (error.code === "FORBIDDEN") {
+    return "\u2717 This API key does not have permission to access this resource.";
+  }
+  if (error.code === "USER_MISMATCH") return "\u2717 The supplied identifiers do not belong to the verified user.";
+  if (error.code === "PROJECT_MISMATCH") return "\u2717 The supplied identifiers do not belong to the verified project.";
+  if (error.code === "NOT_FOUND") {
+    return endpointUrl ? `\u2717 Asiyst API endpoint was not found.
+Verify that the CLI is using:
+${endpointUrl}` : "\u2717 Asiyst API endpoint was not found.";
+  }
+  if (error.code === "TIMEOUT") return "Connection to Asiyst timed out.";
+  if (error.code === "NETWORK") return "\u2717 Unable to reach Asiyst API.";
+  if (error.code === "MALFORMED_RESPONSE") return "Received an unexpected response from Asiyst.";
+  if (error.code === "RATE_LIMITED") return "\u2717 Too many requests. Try again shortly.";
+  if (error.code === "PROJECT_NOT_FOUND") return "\u2717 Authorized project was not found.";
+  if (error.code === "CONFLICT") return "\u2717 The request conflicts with the current project state.";
+  if (error.code === "INVALID_REQUEST") return "\u2717 The request was invalid.";
+  if (error.code === "AVATAR_NOT_FOUND") return "\u2717 Avatar was not found.";
+  if (error.code === "AVATAR_ALREADY_IMPORTED") return "\u2717 This avatar is already imported into the project.";
+  if (error.code === "INTERNAL_ERROR") return "\u2717 Asiyst is temporarily unavailable.";
+  return "\u2717 Asiyst request failed.";
+}
+
+// src/api/verification.ts
+function record(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) {
+    throw new ApiError("Received an unexpected response from Asiyst.", 200, "MALFORMED_RESPONSE");
+  }
+  const root = value;
+  const data = root.data && typeof root.data === "object" && !Array.isArray(root.data) ? root.data : root;
+  return data;
+}
+function stringValue(body, ...keys) {
+  for (const key of keys) {
+    if (typeof body[key] === "string" && body[key].trim()) return body[key].trim();
+  }
+  return void 0;
+}
+function nestedStringValue(body, containers, ...keys) {
+  const direct = stringValue(body, ...keys);
+  if (direct) return direct;
+  for (const container of containers) {
+    const nested = body[container];
+    if (nested && typeof nested === "object" && !Array.isArray(nested)) {
+      const value = stringValue(nested, ...keys);
+      if (value) return value;
+    }
+  }
+  return void 0;
+  return void 0;
+}
+function assertValid(value, name, validator) {
+  const trimmed = value.trim();
+  if (!validator(trimmed)) {
+    const code = name === "User ID" ? "INVALID_USER_ID" : name === "Project ID" ? "INVALID_PROJECT_ID" : name === "Avatar ID" ? "INVALID_AVATAR_ID" : "INVALID_API_KEY";
+    throw new ApiError(`Invalid ${name}.`, 400, code);
+  }
+  return trimmed;
+}
+function assertVerified(body, message) {
+  if (body.valid === false || body.verified === false || body.success === false) {
+    throw new ApiError(stringValue(body, "message", "error") ?? message, 400, "FORBIDDEN");
+  }
+}
+async function verifyUser(api, userId) {
+  const verifiedUserId = assertValid(userId, "User ID", isValidUserId);
+  const body = record(await api.request("/verify/user", {
+    method: "POST",
+    body: JSON.stringify({ userId: verifiedUserId })
+  }));
+  assertVerified(body, "User ID verification failed.");
+  const returned = nestedStringValue(body, ["user"], "userId", "user_id", "id");
+  if (returned !== verifiedUserId) throw new ApiError("The API returned a different User ID.", 200, "USER_MISMATCH");
+  return { userId: verifiedUserId, userName: stringValue(body, "userName", "name") };
+}
+async function verifyProject(api, userId, projectId) {
+  const verifiedUserId = assertValid(userId, "User ID", isValidUserId);
+  const verifiedProjectId = assertValid(projectId, "Project ID", isValidProjectId);
+  const body = record(await api.request("/verify/project", {
+    method: "POST",
+    body: JSON.stringify({ userId: verifiedUserId, projectId: verifiedProjectId })
+  }));
+  assertVerified(body, "Project verification failed.");
+  const returnedProjectId = nestedStringValue(body, ["project"], "projectId", "project_id", "id");
+  const returnedUserId = nestedStringValue(body, ["user"], "userId", "user_id", "id");
+  if (returnedProjectId && returnedProjectId !== verifiedProjectId) throw new ApiError("The API returned a different Project ID.", 200, "PROJECT_MISMATCH");
+  if (returnedUserId && returnedUserId !== verifiedUserId) throw new ApiError("The API returned a different User ID.", 200, "USER_MISMATCH");
+  return {
+    userId: verifiedUserId,
+    projectId: verifiedProjectId,
+    projectName: nestedStringValue(body, ["project"], "projectName", "project_name", "name"),
+    website: nestedStringValue(body, ["project"], "website", "websiteUrl", "website_url", "domain"),
+    publicKey: nestedStringValue(body, ["project"], "publicKey", "public_key", "publishableKey")
+  };
+}
+async function verifyApiKeyRelationship(api, input) {
+  const userId = assertValid(input.userId, "User ID", isValidUserId);
+  const projectId = assertValid(input.projectId, "Project ID", isValidProjectId);
+  const apiKey = assertValid(input.apiKey, "API key", isValidApiKey);
+  const body = record(await api.request("/verify/api-key", {
+    method: "POST",
+    headers: { Authorization: `Bearer ${apiKey}`, "X-Asiyst-API-Key": apiKey },
+    body: JSON.stringify({ userId, projectId, apiKey })
+  }));
+  assertVerified(body, "API key verification failed.");
+  const returnedUserId = nestedStringValue(body, ["user"], "userId", "user_id", "id");
+  const returnedProjectId = nestedStringValue(body, ["project"], "projectId", "project_id", "id");
+  if (returnedUserId && returnedUserId !== userId) throw new ApiError("The API returned a different User ID.", 200, "USER_MISMATCH");
+  if (returnedProjectId && returnedProjectId !== projectId) throw new ApiError("The API returned a different Project ID.", 200, "PROJECT_MISMATCH");
+  return {
+    apiKey,
+    userId,
+    projectId,
+    projectName: nestedStringValue(body, ["project"], "projectName", "project_name", "name"),
+    website: nestedStringValue(body, ["project"], "website", "websiteUrl", "website_url", "domain"),
+    publicKey: nestedStringValue(body, ["project"], "publicKey", "public_key", "publishableKey")
+  };
+}
+async function verifyAvatar(api, input) {
+  const userId = assertValid(input.userId, "User ID", isValidUserId);
+  const projectId = assertValid(input.projectId, "Project ID", isValidProjectId);
+  const apiKey = assertValid(input.apiKey, "API key", isValidApiKey);
+  const avatarId = assertValid(input.avatarId, "Avatar ID", isValidAvatarId);
+  const body = record(await api.request("/verify/avatar", {
+    method: "POST",
+    headers: { Authorization: `Bearer ${apiKey}`, "X-Asiyst-API-Key": apiKey },
+    body: JSON.stringify({ userId, projectId, apiKey, avatarId })
+  }));
+  assertVerified(body, "Avatar verification failed.");
+  const returnedAvatarId = nestedStringValue(body, ["avatar"], "avatarId", "avatar_id", "id");
+  const returnedUserId = nestedStringValue(body, ["user"], "userId", "user_id", "id");
+  const returnedProjectId = nestedStringValue(body, ["project"], "projectId", "project_id", "id");
+  if (returnedAvatarId && returnedAvatarId !== avatarId) throw new ApiError("The API returned a different Avatar ID.", 200, "AVATAR_MISMATCH");
+  if (returnedUserId && returnedUserId !== userId) throw new ApiError("The API returned a different User ID.", 200, "USER_MISMATCH");
+  if (returnedProjectId && returnedProjectId !== projectId) throw new ApiError("The API returned a different Project ID.", 200, "PROJECT_MISMATCH");
+  return { userId, projectId, avatarId, avatarName: nestedStringValue(body, ["avatar"], "avatarName", "avatar_name", "name") };
+}
+async function createImportSession(api, input) {
+  const userId = assertValid(input.userId, "User ID", isValidUserId);
+  const projectId = assertValid(input.projectId, "Project ID", isValidProjectId);
+  const apiKey = assertValid(input.apiKey, "API key", isValidApiKey);
+  const avatarId = assertValid(input.avatarId, "Avatar ID", isValidAvatarId);
+  const body = record(await api.request("/import-session", {
+    method: "POST",
+    headers: { Authorization: `Bearer ${apiKey}`, "X-Asiyst-API-Key": apiKey },
+    body: JSON.stringify({ userId, projectId, apiKey, avatarId })
+  }));
+  const sessionId = stringValue(body, "sessionId", "session_id", "id");
+  if (!sessionId) throw new ApiError("The API did not return an import session.", 200, "MALFORMED_RESPONSE");
+  return { sessionId, expiresAt: stringValue(body, "expiresAt", "expires_at") };
+}
+
+// src/browser/open.ts
+import { execFile } from "child_process";
+import { promisify } from "util";
+var execFileAsync = promisify(execFile);
+async function openBrowser(url) {
+  const command = process.platform === "win32" ? "rundll32.exe" : process.platform === "darwin" ? "open" : "xdg-open";
+  const args = process.platform === "win32" ? ["url.dll,FileProtocolHandler", url] : [url];
+  try {
+    await execFileAsync(command, args);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+// src/config/api.ts
+var PRODUCTION_API_ORIGIN = "https://nqhxpgsjofzqudyqkqib.supabase.co/functions/v1/api";
+var CLI_API_BASE_URL = PRODUCTION_API_ORIGIN;
+var VERIFY_KEY_PATH = "/auth/api-key/verify";
+var VERIFY_KEY_URL = `${CLI_API_BASE_URL}${VERIFY_KEY_PATH}`;
+var ASIYST_WEB_URL = "https://asiyst.com";
+var ASIIYST_WEB_URL = ASIYST_WEB_URL;
+var REQUEST_TIMEOUT_MS = 15e3;
+function readEnv(env, ...keys) {
+  for (const key of keys) {
+    const value = env[key]?.trim();
+    if (value) return value;
+  }
+  return void 0;
+}
+function isLocalUrl(value) {
+  try {
+    const url = new URL(value);
+    return url.hostname === "localhost" || url.hostname === "127.0.0.1" || url.hostname === "::1";
+  } catch {
+    return /localhost|127\.0\.0\.1|::1/i.test(value);
+  }
+}
+function resolveApiBaseUrl(env = process.env) {
+  const explicit = readEnv(env, "ASIYST_API_URL", "ASIIYST_API_URL");
+  const development = readEnv(env, "ASIYST_API_MODE", "ASIIYST_API_MODE") === "development";
+  if (explicit) {
+    if (isLocalUrl(explicit)) {
+      return CLI_API_BASE_URL;
+    }
+    return explicit.replace(/\/+$/, "");
+  }
+  if (development) {
+    return CLI_API_BASE_URL;
+  }
+  return CLI_API_BASE_URL;
+}
+function isDebugEnabled(env = process.env) {
+  return readEnv(env, "ASIYST_DEBUG", "ASIIYST_DEBUG") === "1" || readEnv(env, "ASIYST_DEBUG", "ASIIYST_DEBUG") === "true";
+}
+
+// src/config/credentials.ts
+import { execFile as execFile2 } from "child_process";
+import { existsSync, mkdirSync, readFileSync, unlinkSync, writeFileSync } from "fs";
+import { homedir } from "os";
+import { join, resolve } from "path";
+import { promisify as promisify2 } from "util";
+var execFileAsync2 = promisify2(execFile2);
+function configDir() {
+  if (process.platform === "win32") return join(process.env.APPDATA || join(homedir(), "AppData", "Roaming"), "asiyst");
+  if (process.platform === "darwin") return join(homedir(), "Library", "Application Support", "asiyst");
+  return join(homedir(), ".config", "asiyst");
+}
+function storePath() {
+  return join(configDir(), "credentials.json");
+}
+function accountFor(cwd) {
+  return resolve(cwd);
+}
+function readStore() {
+  const path = storePath();
+  if (!existsSync(path)) return {};
+  try {
+    const parsed = JSON.parse(readFileSync(path, "utf8"));
+    if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) return {};
+    return parsed;
+  } catch {
+    return {};
+  }
+}
+function writeStore(data) {
+  mkdirSync(configDir(), { recursive: true, mode: 448 });
+  writeFileSync(storePath(), JSON.stringify(data, null, 2), { encoding: "utf8", mode: 384 });
+}
+async function dpapiProtect(plaintext) {
+  if (process.platform !== "win32") return void 0;
+  const script = [
+    "Add-Type -AssemblyName System.Security",
+    "$bytes = [System.Text.Encoding]::UTF8.GetBytes($env:ASIYST_DPAPI_PAYLOAD)",
+    "$protected = [System.Security.Cryptography.ProtectedData]::Protect($bytes, $null, [System.Security.Cryptography.DataProtectionScope]::CurrentUser)",
+    "[Convert]::ToBase64String($protected)"
+  ].join("; ");
+  try {
+    const { stdout: stdout5 } = await execFileAsync2("powershell.exe", ["-NoProfile", "-NonInteractive", "-Command", script], {
+      env: { ...process.env, ASIYST_DPAPI_PAYLOAD: plaintext },
+      windowsHide: true
+    });
+    const value = stdout5.trim();
+    return value || void 0;
+  } catch {
+    return void 0;
+  }
+}
+async function dpapiUnprotect(payload) {
+  if (process.platform !== "win32") return void 0;
+  const script = [
+    "Add-Type -AssemblyName System.Security",
+    "$protected = [Convert]::FromBase64String($env:ASIYST_DPAPI_PAYLOAD)",
+    "$bytes = [System.Security.Cryptography.ProtectedData]::Unprotect($protected, $null, [System.Security.Cryptography.DataProtectionScope]::CurrentUser)",
+    "[System.Text.Encoding]::UTF8.GetString($bytes)"
+  ].join("; ");
+  try {
+    const { stdout: stdout5 } = await execFileAsync2("powershell.exe", ["-NoProfile", "-NonInteractive", "-Command", script], {
+      env: { ...process.env, ASIYST_DPAPI_PAYLOAD: payload },
+      windowsHide: true
+    });
+    const value = stdout5.trim();
+    return value || void 0;
+  } catch {
+    return void 0;
+  }
+}
+function windowsBlobPath() {
+  return join(configDir(), "credentials.dpapi");
+}
+async function saveConnection(cwd, connection) {
+  const account = accountFor(cwd);
+  const next = { ...readStore(), [account]: connection };
+  if (process.platform === "win32") {
+    const protectedBlob = await dpapiProtect(JSON.stringify(next));
+    if (protectedBlob) {
+      mkdirSync(configDir(), { recursive: true, mode: 448 });
+      writeFileSync(windowsBlobPath(), protectedBlob, { encoding: "utf8", mode: 384 });
+      if (existsSync(storePath())) unlinkSync(storePath());
+      return;
+    }
+  }
+  writeStore(next);
+}
+async function loadConnection(cwd) {
+  const account = accountFor(cwd);
+  if (process.platform === "win32" && existsSync(windowsBlobPath())) {
+    const decrypted = await dpapiUnprotect(readFileSync(windowsBlobPath(), "utf8"));
+    if (decrypted) {
+      try {
+        const parsed = JSON.parse(decrypted);
+        if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) {
+          const entry2 = parsed[account];
+          if (entry2 && typeof entry2.apiKey === "string" && typeof entry2.projectId === "string") return entry2;
+        }
+      } catch {
+        return void 0;
+      }
+    }
+  }
+  const entry = readStore()[account];
+  if (entry && typeof entry.apiKey === "string" && typeof entry.projectId === "string") return entry;
+  return void 0;
+}
+async function clearConnection(cwd) {
+  const account = accountFor(cwd);
+  if (process.platform === "win32" && existsSync(windowsBlobPath())) {
+    const decrypted = await dpapiUnprotect(readFileSync(windowsBlobPath(), "utf8"));
+    let next2 = {};
+    if (decrypted) {
+      try {
+        const parsed = JSON.parse(decrypted);
+        if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) next2 = { ...parsed };
+      } catch {
+        next2 = {};
+      }
+    }
+    delete next2[account];
+    if (Object.keys(next2).length === 0) {
+      unlinkSync(windowsBlobPath());
+      return;
+    }
+    const protectedBlob = await dpapiProtect(JSON.stringify(next2));
+    if (protectedBlob) {
+      writeFileSync(windowsBlobPath(), protectedBlob, { encoding: "utf8", mode: 384 });
+      return;
+    }
+  }
+  const next = readStore();
+  delete next[account];
+  if (Object.keys(next).length === 0 && existsSync(storePath())) unlinkSync(storePath());
+  else writeStore(next);
+}
+
+// src/config/project.ts
+import { existsSync as existsSync2, mkdirSync as mkdirSync2, readFileSync as readFileSync2, writeFileSync as writeFileSync2 } from "fs";
+import { join as join2, resolve as resolve2 } from "path";
+var PROJECT_CONFIG_DIR = ".asiyst";
+var PROJECT_CONFIG_FILE = "config.json";
+function projectConfigPath(cwd) {
+  return join2(resolve2(cwd), PROJECT_CONFIG_DIR, PROJECT_CONFIG_FILE);
+}
+function readProjectMetadata(cwd) {
+  const path = projectConfigPath(cwd);
+  if (!existsSync2(path)) return void 0;
+  try {
+    const parsed = JSON.parse(readFileSync2(path, "utf8"));
+    if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) return void 0;
+    const body = parsed;
+    if (typeof body.apiKey === "string") delete body.apiKey;
+    return {
+      projectId: typeof body.projectId === "string" ? body.projectId : void 0,
+      projectName: typeof body.projectName === "string" ? body.projectName : void 0,
+      website: typeof body.website === "string" ? body.website : void 0,
+      publicKey: typeof body.publicKey === "string" ? body.publicKey : void 0,
+      userId: typeof body.userId === "string" ? body.userId : void 0,
+      avatarId: typeof body.avatarId === "string" ? body.avatarId : void 0,
+      avatarName: typeof body.avatarName === "string" ? body.avatarName : void 0,
+      connected: body.connected === true
+    };
+  } catch {
+    return void 0;
+  }
+}
+function writeProjectMetadata(cwd, connection) {
+  const dir = join2(resolve2(cwd), PROJECT_CONFIG_DIR);
+  mkdirSync2(dir, { recursive: true });
+  const existing = readProjectMetadata(cwd) ?? {};
+  const next = {
+    ...existing,
+    projectId: connection.projectId,
+    projectName: connection.projectName,
+    website: connection.website,
+    publicKey: connection.publicKey,
+    userId: connection.userId,
+    avatarId: connection.avatarId,
+    avatarName: connection.avatarName,
+    connected: true
+  };
+  writeFileSync2(projectConfigPath(cwd), `${JSON.stringify(next, null, 2)}
+`, { encoding: "utf8" });
+}
+function clearProjectMetadata(cwd) {
+  const path = projectConfigPath(cwd);
+  if (!existsSync2(path)) return;
+  const existing = readProjectMetadata(cwd) ?? {};
+  const next = {
+    ...existing,
+    connected: false
+  };
+  writeFileSync2(path, `${JSON.stringify(next, null, 2)}
+`, { encoding: "utf8" });
 }
 
 // src/detection/project.ts
-import { existsSync, readFileSync } from "fs";
-import { resolve } from "path";
+import { existsSync as existsSync3, readFileSync as readFileSync3 } from "fs";
+import { resolve as resolve3 } from "path";
 function dependencyVersion(pkg) {
   const sections = ["dependencies", "devDependencies", "peerDependencies", "optionalDependencies"];
-  for (const section of sections) {
-    const values = pkg[section];
+  for (const section2 of sections) {
+    const values = pkg[section2];
     if (values && typeof values === "object" && "@asiyst/sdk" in values) {
       const version = values["@asiyst/sdk"];
       return typeof version === "string" ? version : void 0;
@@ -48,30 +488,37 @@ function dependencyVersion(pkg) {
   }
   return void 0;
 }
+function hasDependency(deps, name) {
+  return typeof deps[name] === "string";
+}
 function detectFramework(cwd, pkg) {
   const deps = Object.assign({}, pkg?.dependencies, pkg?.devDependencies);
-  if (typeof deps.next === "string") return "Next.js";
-  if (typeof deps.react === "string") return "React";
-  if (typeof deps.vite === "string") return "Vite";
-  if (typeof deps.vue === "string") return "Vue";
-  if (existsSync(resolve(cwd, "vite.config.ts")) || existsSync(resolve(cwd, "vite.config.js"))) return "Vite";
-  if (existsSync(resolve(cwd, "next.config.js")) || existsSync(resolve(cwd, "next.config.mjs"))) return "Next.js";
-  return "Vanilla JavaScript/TypeScript";
+  if (hasDependency(deps, "next") || existsSync3(resolve3(cwd, "next.config.js")) || existsSync3(resolve3(cwd, "next.config.mjs")) || existsSync3(resolve3(cwd, "next.config.ts"))) {
+    return "Next.js";
+  }
+  if (hasDependency(deps, "nuxt")) return "Nuxt";
+  if (hasDependency(deps, "vue") || existsSync3(resolve3(cwd, "vue.config.js"))) return "Vue";
+  if (hasDependency(deps, "react")) return "React";
+  if (hasDependency(deps, "vite") || existsSync3(resolve3(cwd, "vite.config.ts")) || existsSync3(resolve3(cwd, "vite.config.js")) || existsSync3(resolve3(cwd, "vite.config.mjs"))) {
+    return "Vite";
+  }
+  if (pkg) return existsSync3(resolve3(cwd, "tsconfig.json")) ? "Vanilla TypeScript" : "Vanilla JavaScript";
+  return "Unknown";
 }
 function detectProject(cwd = process.cwd()) {
-  const path = resolve(cwd, "package.json");
+  const path = resolve3(cwd, "package.json");
   let packageJson = null;
-  if (existsSync(path)) {
+  if (existsSync3(path)) {
     try {
-      const value = JSON.parse(readFileSync(path, "utf8"));
+      const value = JSON.parse(readFileSync3(path, "utf8"));
       if (value && typeof value === "object" && !Array.isArray(value)) packageJson = value;
     } catch {
       packageJson = null;
     }
   }
   const env = process.env;
-  const packageManager = existsSync(resolve(cwd, "pnpm-lock.yaml")) ? "pnpm" : existsSync(resolve(cwd, "yarn.lock")) ? "yarn" : existsSync(resolve(cwd, "bun.lockb")) || existsSync(resolve(cwd, "bun.lock")) ? "bun" : "npm";
-  const sourceFiles = ["tsconfig.json", "src", "app"].some((entry) => existsSync(resolve(cwd, entry)));
+  const packageManager = existsSync3(resolve3(cwd, "pnpm-lock.yaml")) ? "pnpm" : existsSync3(resolve3(cwd, "yarn.lock")) ? "yarn" : existsSync3(resolve3(cwd, "bun.lockb")) || existsSync3(resolve3(cwd, "bun.lock")) ? "bun" : "npm";
+  const sourceFiles = ["tsconfig.json", "src", "app"].some((entry) => existsSync3(resolve3(cwd, entry)));
   return {
     cwd,
     packageJson,
@@ -86,370 +533,709 @@ function detectProject(cwd = process.cwd()) {
   };
 }
 
-// src/config/api.ts
-var CLI_API_BASE_URL = "https://asiyst.com/api/v1";
-var ASIIYST_WEB_URL = "https://asiyst.com";
-
-// src/api/client.ts
-var ApiError = class extends Error {
-  constructor(message, status) {
-    super(message);
-    this.status = status;
-    this.name = "ApiError";
-  }
-  status;
+// src/ui/format.ts
+import { stdout } from "process";
+var supportsColor = Boolean(stdout.isTTY && !process.env.NO_COLOR && process.env.TERM !== "dumb");
+var codes = {
+  reset: "\x1B[0m",
+  bold: "\x1B[1m",
+  dim: "\x1B[2m",
+  cyan: "\x1B[36m",
+  green: "\x1B[32m",
+  yellow: "\x1B[33m",
+  red: "\x1B[31m"
 };
-var ApiClient = class {
-  constructor(baseUrl = process.env.ASIIYST_API_URL || CLI_API_BASE_URL, fetcher = fetch) {
-    this.fetcher = fetcher;
-    this.baseUrl = baseUrl.replace(/\/+$/, "");
-  }
-  fetcher;
-  baseUrl;
-  async request(path, init) {
-    let response;
-    const controller = new AbortController();
-    const timeout = setTimeout(() => controller.abort(), 1e4);
-    try {
-      response = await this.fetcher(`${this.baseUrl}${path}`, {
-        ...init,
-        signal: init?.signal || controller.signal,
-        headers: { Accept: "application/json", "Content-Type": "application/json", ...init?.headers }
-      });
-    } catch (error) {
-      if (error instanceof DOMException && error.name === "AbortError" || error instanceof Error && error.name === "AbortError") {
-        throw new ApiError(`Asiyst API request timed out after 10 seconds: ${this.baseUrl}${path}. Check your connection and try again.`);
-      }
-      throw new ApiError(`Unable to reach Asiyst API at ${this.baseUrl}${path}. Check your internet connection, DNS, TLS/HTTPS, or whether the service is unavailable.`);
-    } finally {
-      clearTimeout(timeout);
-    }
-    const body = await response.json().catch(() => void 0);
-    if (!response.ok) {
-      const detail = response.status === 400 ? "The request data was invalid." : response.status === 401 ? "Authentication is required. Please connect your Asiyst account." : response.status === 403 ? "You are not authorized to perform this operation." : response.status === 404 ? `The API endpoint was not found: ${this.baseUrl}${path}. Please update Asiyst CLI or contact support.` : response.status === 409 ? "The request conflicts with the current project state." : response.status === 422 ? "The request data was invalid." : response.status === 429 ? "Too many requests; try again shortly." : response.status >= 500 ? "Asiyst is temporarily unavailable." : "The request was rejected.";
-      throw new ApiError(`Asiyst API returned HTTP ${response.status}. ${detail}`, response.status);
-    }
-    if (body === void 0) {
-      throw new ApiError(`Asiyst API returned an invalid JSON response (HTTP ${response.status}).`, response.status);
-    }
-    return body;
-  }
-  health() {
-    return this.request("/health").then((body) => {
-      if (!body || typeof body !== "object" || Array.isArray(body)) {
-        throw new ApiError("Asiyst API health endpoint returned an invalid response.");
-      }
-      return body;
-    });
-  }
-  createSession() {
-    return this.request("/cli/sessions", { method: "POST", body: JSON.stringify({}) }).then((value) => {
-      if (!value || typeof value !== "object") throw new ApiError("Asiyst returned an invalid session response");
-      const session = value;
-      if (typeof session.sessionId !== "string" || typeof session.connectUrl !== "string" || typeof session.expiresAt !== "string") {
-        throw new ApiError("Asiyst returned an invalid session response");
-      }
-      const url = new URL(session.connectUrl);
-      if (url.protocol !== "https:") {
-        throw new ApiError("Asiyst returned an insecure connection URL");
-      }
-      return { sessionId: session.sessionId, connectUrl: url.toString(), expiresAt: session.expiresAt };
-    });
-  }
-  sessionStatus(sessionId) {
-    return this.request(`/cli/sessions/${encodeURIComponent(sessionId)}/status`);
-  }
-  projectInfo(projectId) {
-    return this.request(`/cli/projects/${encodeURIComponent(projectId)}`);
-  }
-  verify(projectId, publicKey, domain) {
-    return this.request("/cli/verification", {
-      method: "POST",
-      body: JSON.stringify({ projectId, publicKey, domain })
-    }).then((value) => {
-      if (!Array.isArray(value) || !value.every((item) => item && typeof item === "object" && typeof item.name === "string" && typeof item.ok === "boolean")) {
-        throw new ApiError("Asiyst returned an invalid verification response");
-      }
-      return value;
-    });
-  }
+function color(code, value) {
+  return supportsColor ? `${codes[code]}${value}${codes.reset}` : value;
+}
+var symbols = {
+  connected: "\u25CF",
+  disconnected: "\u25CB",
+  warning: "\u26A0",
+  error: "\u2715",
+  success: "\u2713",
+  pointer: "\u203A"
 };
-
-// src/config/local.ts
-import { existsSync as existsSync2, readFileSync as readFileSync2 } from "fs";
-import { resolve as resolve2 } from "path";
-function configWarning(cwd) {
-  const envPath = resolve2(cwd, ".env");
-  if (existsSync2(envPath)) {
-    const ignored = existsSync2(resolve2(cwd, ".gitignore")) && readFileSync2(resolve2(cwd, ".gitignore"), "utf8").split(/\r?\n/).some((line) => line.trim() === ".env" || line.trim() === ".env.*");
-    if (!ignored) return "Your .env file is not clearly ignored by .gitignore; do not commit public or private configuration accidentally.";
-  }
-  return void 0;
+function title(value) {
+  return color("bold", value);
+}
+function section(value) {
+  return color("cyan", value);
+}
+function muted(value) {
+  return color("dim", value);
+}
+function success(value) {
+  return color("green", value);
+}
+function warning(value) {
+  return color("yellow", value);
+}
+function maskSecret(value, visible = 0) {
+  if (visible <= 0) return "\u2022\u2022\u2022\u2022\u2022\u2022\u2022\u2022";
+  return `${value.slice(0, visible)}\u2022\u2022\u2022\u2022\u2022\u2022\u2022\u2022`;
+}
+function printHeader(value, subtitle) {
+  console.log(`
+${title(value)}`);
+  if (subtitle) console.log(muted(subtitle));
+  console.log();
 }
 
-// src/browser/open.ts
-import { execFile } from "child_process";
-import { promisify } from "util";
-var execFileAsync = promisify(execFile);
-async function openBrowser(url) {
-  const command = process.platform === "win32" ? "rundll32.exe" : process.platform === "darwin" ? "open" : "xdg-open";
-  const args = process.platform === "win32" ? ["url.dll,FileProtocolHandler", url] : [url];
-  try {
-    await execFileAsync(command, args);
-    return true;
-  } catch {
-    return false;
-  }
+// src/ui/output.ts
+var ok = (label, detail = "") => console.log(`${success(symbols.success)} ${label}${detail ? ` (${detail})` : ""}`);
+var fail = (label, detail = "") => console.log(`${symbols.error} ${label}${detail ? `: ${detail}` : ""}`);
+function projectChecks(project) {
+  project.packageJson ? ok("Project detected", typeof project.packageJson.name === "string" ? project.packageJson.name : project.cwd) : fail("Project not detected", "package.json is missing");
+  if (project.framework === "Unknown") fail("Framework detected", "No supported project type was identified.");
+  else ok("Framework detected", project.framework);
+  ok("Language detected", project.language);
+  ok("Node.js detected", process.version);
+  ok("Package manager detected", project.packageManager);
+  project.sdkVersion ? ok("@asiyst/sdk detected", project.sdkVersion) : console.log(`${muted(symbols.disconnected)} @asiyst/sdk not installed. Install it with your package manager.`);
+}
+function printProjectSummary(project, connected, projectName, website) {
+  console.log(title("Asiyst CLI"));
+  console.log();
+  console.log(section("Project"));
+  console.log(`  ${projectName || (typeof project.packageJson?.name === "string" ? project.packageJson.name : project.cwd)}`);
+  if (website) console.log(`  ${muted(website)}`);
+  const marker = connected ? success(symbols.connected) : muted(symbols.disconnected);
+  console.log(`  ${marker} ${connected ? "Connected" : "Not connected"}`);
+  console.log();
+  console.log(section("Environment"));
+  console.log(`  ${project.framework} \xB7 ${project.language} \xB7 ${project.packageManager}`);
 }
 
 // src/ui/selector.ts
-import { stdin, stdout } from "process";
+import { stdin, stdout as stdout2 } from "process";
 import { clearLine, cursorTo, emitKeypressEvents, moveCursor } from "readline";
-var width = () => Math.max(40, (stdout.columns || 80) - 2);
-var fit = (value) => value.length > width() ? `${value.slice(0, width() - 1)}\u2026` : value;
+var HIDE_CURSOR = "\x1B[?25l";
+var SHOW_CURSOR = "\x1B[?25h";
 function moveSelection(active, optionCount, direction) {
   if (optionCount === 0) return 0;
   return direction === "up" ? Math.max(0, active - 1) : Math.min(optionCount - 1, active + 1);
 }
 function clearSelectorFrame(output, previousLineCount) {
-  if (previousLineCount === 0) return;
-  moveCursor(output, 0, -previousLineCount);
+  if (previousLineCount <= 0) return;
+  cursorTo(output, 0);
+  for (let i = 0; i < previousLineCount - 1; i += 1) {
+    moveCursor(output, 0, -1);
+  }
   for (let line = 0; line < previousLineCount; line += 1) {
     cursorTo(output, 0);
     clearLine(output, 0);
-    if (line < previousLineCount - 1) moveCursor(output, 0, 1);
+    if (line < previousLineCount - 1) {
+      moveCursor(output, 0, 1);
+    }
   }
   cursorTo(output, 0);
+  for (let i = 0; i < previousLineCount - 1; i += 1) {
+    moveCursor(output, 0, -1);
+  }
 }
 function renderSelectorFrame(output, previousLineCount, lines) {
-  clearSelectorFrame(output, previousLineCount);
-  output.write(lines.join("\n"));
-  output.write("\n");
+  if (lines.length === 0) return 0;
+  if (previousLineCount > 0) {
+    cursorTo(output, 0);
+    for (let i = 0; i < previousLineCount - 1; i += 1) {
+      moveCursor(output, 0, -1);
+    }
+  }
+  for (let i = 0; i < lines.length; i += 1) {
+    cursorTo(output, 0);
+    clearLine(output, 0);
+    output.write(lines[i]);
+    if (i < lines.length - 1) {
+      output.write("\n");
+    }
+  }
   return lines.length;
 }
-function selectOption(title, options, prompt = "> ") {
-  if (!stdin.isTTY || !stdout.isTTY) return Promise.resolve({ type: "cancelled", input: "" });
-  return new Promise((resolve4) => {
-    let input = "";
+function restoreTerminal(wasRaw) {
+  stdout2.write(SHOW_CURSOR);
+  if (stdin.isTTY) stdin.setRawMode?.(wasRaw);
+}
+function selectOption(title2, options) {
+  if (!stdin.isTTY || !stdout2.isTTY) return Promise.resolve({ type: "cancelled" });
+  return new Promise((resolve6) => {
     let active = 0;
-    let visible = true;
     let renderedLines = 0;
     let settled = false;
-    const filtered = () => {
-      const query = input.trim().toLowerCase();
-      return query ? options.filter((option) => option.label.toLowerCase().includes(query) || String(option.value).toLowerCase().includes(query)) : options;
-    };
-    const clear = () => {
-      clearSelectorFrame(stdout, renderedLines);
-      renderedLines = 0;
-    };
-    const render = () => {
-      clear();
-      const matches = filtered();
-      if (active >= matches.length) active = Math.max(0, matches.length - 1);
-      const lines = [`${title}`, `${prompt}${fit(input)}`];
-      if (visible) {
-        if (matches.length === 0) lines.push("  No matching commands.");
-        else lines.push(...matches.map((option, index) => `${index === active ? "\u276F" : " "} ${fit(option.label)}`));
-        lines.push("\u2191\u2193 Navigate  Enter Select  Esc Cancel");
-      }
-      renderedLines = renderSelectorFrame(stdout, renderedLines, lines);
-    };
-    const finish = (result) => {
+    const wasRaw = Boolean(stdin.isRaw);
+    const enabled = options.filter((option) => !option.disabled);
+    const finish = (result, confirmation) => {
       if (settled) return;
       settled = true;
       stdin.off("keypress", onKeypress);
-      clear();
-      stdin.setRawMode?.(false);
+      clearSelectorFrame(stdout2, renderedLines);
+      restoreTerminal(wasRaw);
       stdin.pause();
-      stdout.write("\n");
-      resolve4(result);
+      if (confirmation) stdout2.write(`${confirmation}
+`);
+      resolve6(result);
+    };
+    const render = () => {
+      const lines = [title2, "", ...enabled.map((option, index) => `${index === active ? "\u276F" : " "} ${option.label}`)];
+      renderedLines = renderSelectorFrame(stdout2, renderedLines, lines);
     };
-    const onKeypress = (value, key) => {
-      if (key.ctrl && key.name === "c") return finish({ type: "cancelled", input });
-      if (key.ctrl && key.name === "d") return finish({ type: "exit", input });
-      if (key.name === "escape") {
-        return finish({ type: "cancelled", input });
+    const onKeypress = (_value, key) => {
+      if (!key) return;
+      if (key.ctrl && key.name === "c") {
+        clearSelectorFrame(stdout2, renderedLines);
+        restoreTerminal(wasRaw);
+        stdin.pause();
+        stdout2.write("\n");
+        process.exit(130);
       }
+      if (key.name === "escape") return finish({ type: "cancelled" });
       if (key.name === "up" || key.name === "down") {
-        const matches = filtered();
-        if (matches.length > 0) {
-          active = moveSelection(active, matches.length, key.name);
-        }
-        visible = true;
+        active = moveSelection(active, enabled.length, key.name);
         return render();
       }
       if (key.name === "return" || key.name === "enter") {
-        const matches = filtered();
-        const selected = matches[active];
-        if (selected) return finish({ type: "selected", value: selected.value, input });
-        return finish({ type: "cancelled", input });
-      }
-      if (key.name === "tab") {
-        const matches = filtered();
-        if (matches.length === 1) input = matches[0].value;
-        else if (matches.length > 1) active = (active + 1) % matches.length;
-        visible = true;
-        return render();
-      }
-      if (key.name === "backspace") {
-        input = input.slice(0, -1);
-        visible = true;
-        return render();
-      }
-      const sequence = key.sequence || value;
-      if (/^[\x20-\x7e]+$/.test(sequence)) {
-        input += sequence;
-        active = 0;
-        visible = true;
-        return render();
+        const selected = enabled[active];
+        if (!selected) return finish({ type: "cancelled" });
+        return finish({ type: "selected", value: selected.value }, `\u2713 ${selected.label} selected.`);
       }
     };
     emitKeypressEvents(stdin);
     stdin.setRawMode?.(true);
     stdin.resume();
+    stdout2.write(HIDE_CURSOR);
     stdin.on("keypress", onKeypress);
     render();
   });
 }
 
-// src/commands/shared.ts
-async function connect(api = new ApiClient()) {
-  await api.health();
-  const session = await api.createSession();
-  console.log(`Opening Asiyst...
-${session.connectUrl}`);
-  if (!await openBrowser(session.connectUrl)) console.log("Automatic browser opening failed; open the URL above.");
-  console.log("\u25CF Waiting for authentication\n\u25CF Waiting for project selection\n\u25CF Waiting for connection");
-  const expires = Date.parse(session.expiresAt);
-  for (; ; ) {
-    const result = await api.sessionStatus(session.sessionId);
-    if (result.state === "completed") return { session, project: result.project };
-    if (result.state === "expired") throw new Error("Connection session expired.");
-    if (result.state === "cancelled") throw new Error("Connection session was cancelled.");
-    if (Number.isFinite(expires) && Date.now() >= expires) throw new Error("Connection session expired.");
-    await new Promise((resolve4) => setTimeout(resolve4, 2e3));
-  }
+// src/ui/secret.ts
+import { stdin as stdin2, stdout as stdout3 } from "process";
+import { emitKeypressEvents as emitKeypressEvents2 } from "readline";
+async function readSecret(prompt) {
+  if (!stdin2.isTTY) return void 0;
+  return new Promise((resolve6) => {
+    let value = "";
+    let settled = false;
+    const wasRaw = Boolean(stdin2.isRaw);
+    stdout3.write(prompt);
+    const finish = (result) => {
+      if (settled) return;
+      settled = true;
+      stdin2.off("keypress", onKeypress);
+      if (stdin2.isTTY) stdin2.setRawMode?.(wasRaw);
+      stdin2.pause();
+      stdout3.write("\n");
+      resolve6(result);
+    };
+    const onKeypress = (chunk, key) => {
+      if (!key) return;
+      if (key.ctrl && key.name === "c") {
+        finish(void 0);
+        process.exit(130);
+      }
+      if (key.name === "escape") return finish(void 0);
+      if (key.name === "return" || key.name === "enter") return finish(value.trim());
+      if (key.name === "backspace") {
+        value = value.slice(0, -1);
+        return;
+      }
+      const sequence = key.sequence || chunk;
+      if (sequence && /^[\x20-\x7e]+$/.test(sequence)) value += sequence;
+    };
+    emitKeypressEvents2(stdin2);
+    stdin2.setRawMode?.(true);
+    stdin2.resume();
+    stdin2.on("keypress", onKeypress);
+  });
 }
-async function confirm(question) {
-  if (!process.stdin.isTTY || !process.stdout.isTTY) return true;
-  const result = await selectOption(question, [
-    { label: "Yes", value: true },
-    { label: "No", value: false }
-  ]);
-  return result.type === "selected" && result.value;
+async function readInput(prompt) {
+  if (!stdin2.isTTY) return void 0;
+  return new Promise((resolve6) => {
+    let value = "";
+    const onData = (chunk) => {
+      value += String(chunk);
+      const newline = value.search(/[\r\n]/);
+      if (newline >= 0) {
+        stdin2.off("data", onData);
+        resolve6(value.slice(0, newline).trim());
+      }
+    };
+    stdout3.write(prompt);
+    stdin2.resume();
+    stdin2.on("data", onData);
+  });
 }
 
 // src/config/trust.ts
-import { existsSync as existsSync3, mkdirSync, readFileSync as readFileSync3, writeFileSync } from "fs";
-import { homedir } from "os";
-import { join, resolve as resolve3 } from "path";
-var trustFile = join(homedir(), ".config", "asiyst", "trusted-folders.json");
+import { existsSync as existsSync4, mkdirSync as mkdirSync3, readFileSync as readFileSync4, writeFileSync as writeFileSync3 } from "fs";
+import { homedir as homedir2 } from "os";
+import { join as join3, resolve as resolve4 } from "path";
+var trustFile = join3(homedir2(), ".config", "asiyst", "trusted-folders.json");
 function readTrusted() {
-  if (!existsSync3(trustFile)) return [];
+  if (!existsSync4(trustFile)) return [];
   try {
-    const parsed = JSON.parse(readFileSync3(trustFile, "utf8"));
+    const parsed = JSON.parse(readFileSync4(trustFile, "utf8"));
     return Array.isArray(parsed) && parsed.every((item) => typeof item === "string") ? parsed : [];
   } catch {
     return [];
   }
 }
 function isTrusted(cwd) {
-  return readTrusted().includes(resolve3(cwd));
+  return readTrusted().includes(resolve4(cwd));
 }
 function trustFolder(cwd) {
-  const folder = resolve3(cwd);
+  const folder = resolve4(cwd);
   const trusted = readTrusted();
   if (!trusted.includes(folder)) trusted.push(folder);
-  mkdirSync(join(homedir(), ".config", "asiyst"), { recursive: true, mode: 448 });
-  writeFileSync(trustFile, JSON.stringify(trusted, null, 2), { encoding: "utf8", mode: 384 });
+  mkdirSync3(join3(homedir2(), ".config", "asiyst"), { recursive: true, mode: 448 });
+  writeFileSync3(trustFile, JSON.stringify(trusted, null, 2), { encoding: "utf8", mode: 384 });
 }
 function revokeTrust(cwd) {
-  const folder = resolve3(cwd);
+  const folder = resolve4(cwd);
   const trusted = readTrusted().filter((item) => item !== folder);
-  if (existsSync3(trustFile)) writeFileSync(trustFile, JSON.stringify(trusted, null, 2), { encoding: "utf8", mode: 384 });
+  if (existsSync4(trustFile)) writeFileSync3(trustFile, JSON.stringify(trusted, null, 2), { encoding: "utf8", mode: 384 });
+}
+
+// src/api/client.ts
+function asRecord(value) {
+  return value && typeof value === "object" && !Array.isArray(value) ? value : void 0;
+}
+function bodyErrorCode(body) {
+  const record2 = asRecord(body);
+  const code = record2?.code ?? record2?.errorCode ?? record2?.error ?? asRecord(record2?.error)?.code;
+  return typeof code === "string" ? code : void 0;
+}
+function bodyErrorMessage(body) {
+  const record2 = asRecord(body);
+  const message = record2?.message ?? asRecord(record2?.error)?.message;
+  return typeof message === "string" && message.trim() ? message.trim() : void 0;
+}
+function isAbortError(error) {
+  return error instanceof DOMException && error.name === "AbortError" || error instanceof Error && error.name === "AbortError";
+}
+var ApiClient = class {
+  constructor(baseUrl = resolveApiBaseUrl(), fetcher = fetch) {
+    this.fetcher = fetcher;
+    this.baseUrl = baseUrl.replace(/\/+$/, "");
+  }
+  fetcher;
+  baseUrl;
+  async request(path, init) {
+    const url = `${this.baseUrl}${path}`;
+    const controller = new AbortController();
+    const timeout = setTimeout(() => controller.abort(), REQUEST_TIMEOUT_MS);
+    const headers = new Headers(init?.headers);
+    headers.set("Accept", "application/json");
+    if (!headers.has("Content-Type")) headers.set("Content-Type", "application/json");
+    let response;
+    try {
+      response = await this.fetcher(url, {
+        ...init,
+        headers,
+        signal: init?.signal || controller.signal
+      });
+    } catch (error) {
+      if (isAbortError(error)) {
+        throw new ApiError("Connection to Asiyst timed out.", void 0, "TIMEOUT");
+      }
+      throw new ApiError("Unable to reach Asiyst API.", void 0, "NETWORK");
+    } finally {
+      clearTimeout(timeout);
+    }
+    const rawText = await response.text();
+    let body;
+    if (rawText) {
+      try {
+        body = JSON.parse(rawText);
+      } catch {
+        body = void 0;
+      }
+    }
+    if (!response.ok) {
+      const code = errorCodeFromStatus(response.status, bodyErrorCode(body));
+      if (code === "API_KEY_REVOKED" || bodyErrorCode(body) === "API_KEY_REVOKED") {
+        throw new ApiError("This API key has been revoked.", response.status, "API_KEY_REVOKED");
+      }
+      throw new ApiError(bodyErrorMessage(body) ?? `Asiyst API returned HTTP ${response.status}.`, response.status, code);
+    }
+    if (rawText && body === void 0) {
+      if (isDebugEnabled()) {
+        throw new ApiError("Asiyst API returned an invalid JSON response.", response.status, "MALFORMED_RESPONSE");
+      }
+      throw new ApiError("Received an unexpected response from Asiyst.", response.status, "MALFORMED_RESPONSE");
+    }
+    return body === void 0 ? {} : body;
+  }
+  async health() {
+    try {
+      const body = await this.request("/health");
+      const record2 = asRecord(body);
+      if (record2) return record2;
+    } catch {
+    }
+    throw new ApiError("Received an unexpected response from Asiyst.", 200, "MALFORMED_RESPONSE");
+  }
+};
+
+// src/commands/shared.ts
+async function confirm(question) {
+  if (!process.stdin.isTTY || !process.stdout.isTTY) return false;
+  const result = await selectOption(question, [
+    { label: "Yes", value: true },
+    { label: "No", value: false }
+  ]);
+  return result.type === "selected" && result.value;
+}
+function createApiClient() {
+  return new ApiClient();
+}
+
+// src/commands/trust.ts
+async function ensureTrusted(cwd = process.cwd()) {
+  if (isTrusted(cwd)) return true;
+  if (!await confirm(`Trust this project folder?
+
+${cwd}
+
+Asiyst may read project files and modify Asiyst configuration during setup.`)) {
+    console.log("Folder not trusted.\nExiting...");
+    return false;
+  }
+  trustFolder(cwd);
+  console.log("\u2713 Folder trusted.");
+  return true;
+}
+async function trustCommand(cwd = process.cwd()) {
+  printHeader("Project Trust", cwd);
+  await ensureTrusted(cwd);
+}
+function revokeTrustCommand(cwd = process.cwd()) {
+  revokeTrust(cwd);
+  console.log("\u2713 Project trust revoked.");
+}
+
+// src/commands/connect.ts
+async function retryOrCancel(message) {
+  console.log(message);
+  const result = await selectOption("Options:", [
+    { label: "Retry", value: true },
+    { label: "Cancel", value: false }
+  ]);
+  return result.type === "selected" && result.value;
+}
+function printApiFailure(error) {
+  if (error instanceof ApiError) {
+    if (error.status !== void 0 && error.status < 500 && error.code !== "INVALID_API_KEY" && error.code !== "API_KEY_REVOKED") {
+      return `\u2717 ${error.message}`;
+    }
+    return friendlyApiMessage(error, error.code === "NOT_FOUND" ? VERIFY_KEY_URL : void 0);
+  }
+  if (isDebugEnabled() && error instanceof Error) return `\u2717 ${error.message}`;
+  return "\u2717 Unable to reach Asiyst API.";
+}
+async function promptForProjectId() {
+  const value = await readInput("Enter your Project ID: ");
+  if (value === void 0) {
+    console.log("Connection cancelled.");
+    return void 0;
+  }
+  const trimmed = value.trim();
+  if (!trimmed) {
+    console.log("Project ID is required. Use: asiyst connect --project-id <PROJECT_ID>");
+    return void 0;
+  }
+  return trimmed;
+}
+async function promptForUserId() {
+  const value = await readInput("Enter your Asiyst User ID: ");
+  if (value === void 0) {
+    console.log("Connection cancelled.");
+    return void 0;
+  }
+  if (!isValidUserId(value)) {
+    console.log("Invalid Asiyst User ID.");
+    console.log("Expected: exactly 16 characters using letters, numbers, and hyphens only.");
+    return void 0;
+  }
+  return value.trim();
+}
+async function connectCommand(cwd = process.cwd(), api = createApiClient(), cliProjectId) {
+  printHeader("Connect project", cwd);
+  if (!await ensureTrusted(cwd)) return;
+  const project = detectProject(cwd);
+  projectChecks(project);
+  if (project.framework === "Unknown") {
+    console.log("No supported framework was detected in this folder.");
+  }
+  const shouldConnect = await selectOption("Connect this project to Asiyst?", [
+    { label: "Yes", value: true },
+    { label: "No", value: false }
+  ]);
+  if (shouldConnect.type !== "selected" || !shouldConnect.value) {
+    console.log("Connection cancelled.");
+    return;
+  }
+  console.log("Opening Asiyst...");
+  if (!await openBrowser(ASIIYST_WEB_URL)) {
+    console.log(`Open this URL manually:
+${ASIIYST_WEB_URL}`);
+  }
+  console.log("Register or log in, complete onboarding, create or select a project, then create an API key.");
+  const userId = await promptForUserId();
+  if (!userId) return;
+  try {
+    await verifyUser(api, userId);
+    ok("User verified.");
+  } catch (error) {
+    console.log(printApiFailure(error));
+    return;
+  }
+  const projectIdArg = cliProjectId ?? parseProjectIdArgument(process.argv.slice(2));
+  if (projectIdArg === "") {
+    console.log("Project ID is required. Use: asiyst connect --project-id <PROJECT_ID>");
+    return;
+  }
+  let projectId = typeof projectIdArg === "string" ? projectIdArg.trim() : "";
+  if (!projectId) projectId = await promptForProjectId() || "";
+  if (!projectId) {
+    console.log("Project ID is required. Use: asiyst connect --project-id <PROJECT_ID>");
+    return;
+  }
+  if (!isValidProjectId(projectId)) {
+    console.log("Invalid Project ID. It must be exactly 24 characters.");
+    return;
+  }
+  let verifiedProject;
+  try {
+    verifiedProject = await verifyProject(api, userId, projectId);
+    ok("Project verified.");
+  } catch (error) {
+    console.log(printApiFailure(error));
+    return;
+  }
+  for (; ; ) {
+    const apiKey = await readSecret("Paste your Asiyst API key: ");
+    if (apiKey === void 0) {
+      console.log("Connection cancelled.");
+      return;
+    }
+    if (!isValidApiKey(apiKey)) {
+      fail("Invalid API key. It must be exactly 32 characters.");
+      continue;
+    }
+    try {
+      const connected = await verifyApiKeyRelationship(api, { userId, projectId, apiKey });
+      const finalConnection = {
+        ...connected,
+        projectName: connected.projectName ?? verifiedProject.projectName,
+        website: connected.website ?? verifiedProject.website,
+        publicKey: connected.publicKey ?? verifiedProject.publicKey,
+        projectId,
+        userId
+      };
+      ok("API key verified.");
+      await saveConnection(cwd, finalConnection);
+      writeProjectMetadata(cwd, finalConnection);
+      ok("Project connected successfully.");
+      console.log(`
+Project ID:
+${projectId}`);
+      if (connected.projectName) console.log(`
+Project:
+${connected.projectName}`);
+      if (connected.website) console.log(`
+Website:
+${connected.website}`);
+      return;
+    } catch (error) {
+      const message = printApiFailure(error);
+      const code = error instanceof ApiError ? error.code : "NETWORK";
+      if (code === "INVALID_API_KEY") {
+        console.log(message);
+        continue;
+      }
+      if (code === "API_KEY_REVOKED" || code === "FORBIDDEN" || code === "NOT_FOUND" || code === "MALFORMED_RESPONSE") {
+        console.log(message);
+        return;
+      }
+      if (!await retryOrCancel(message)) {
+        console.log("Connection cancelled.");
+        return;
+      }
+    }
+  }
 }
 
-// src/commands/trust.ts
-async function ensureTrusted(cwd = process.cwd()) {
-  if (isTrusted(cwd)) return true;
-  if (!await confirm(`Trust this project folder?
-
-${cwd}
+// src/commands/login.ts
+async function loginCommand() {
+  await connectCommand(process.cwd(), createApiClient());
+}
 
-Asiyst may read project files and modify Asiyst configuration during setup.`)) {
-    console.log("Folder not trusted.\nExiting...");
-    return false;
+// src/commands/disconnect.ts
+async function disconnectCommand(cwd = process.cwd()) {
+  if (!await confirm("Disconnect this project?")) {
+    console.log("Disconnect cancelled.");
+    return;
   }
-  trustFolder(cwd);
-  console.log("\u2713 Folder trusted.");
-  return true;
-}
-async function trustCommand(cwd = process.cwd()) {
-  await ensureTrusted(cwd);
+  await clearConnection(cwd);
+  clearProjectMetadata(cwd);
+  console.log("\u2713 Local connection information removed.");
+  console.log("The cloud project and API key were not changed.");
 }
-function revokeTrustCommand(cwd = process.cwd()) {
-  revokeTrust(cwd);
-  console.log("\u2713 Folder trust revoked.");
+
+// src/commands/logout.ts
+async function logoutCommand() {
+  await disconnectCommand();
 }
 
-// src/commands/init.ts
-async function initCommand(cwd = process.cwd(), api = new ApiClient()) {
-  if (!await ensureTrusted(cwd)) return;
-  const project = detectProject(cwd);
-  if (!project.packageJson) throw new Error("No package.json found. Run this command from your website project.");
-  console.log(`Detected ${project.framework} project.`);
-  if (!project.sdkVersion) {
-    console.log("\n@asiyst/sdk is not installed.\nRun: npm install @asiyst/sdk");
+// src/commands/status.ts
+async function statusCommand(cwd = process.cwd(), api = createApiClient()) {
+  const stored = await loadConnection(cwd);
+  if (!stored?.apiKey) {
+    printHeader("Asiyst Project Status");
+    printProjectSummary(detectProject(cwd), false);
+    console.log(`
+${warning(symbols.warning)} Not connected to Asiyst.`);
+    return;
+  }
+  if (!stored.userId || !stored.projectId) {
+    console.log(`${symbols.error} Connection is missing a User ID or Project ID. Please run:
+asiyst connect`);
     return;
   }
-  if (!await confirm("Connect this project to Asiyst?")) return;
-  const result = await connect(api);
-  ok("Asiyst account connected");
-  ok("Project connected", result.project?.projectName);
-  if (result.project?.projectId) {
+  try {
+    const connected = await verifyApiKeyRelationship(api, {
+      userId: stored.userId,
+      projectId: stored.projectId,
+      apiKey: stored.apiKey
+    });
+    if (stored.avatarId) {
+      await verifyAvatar(api, {
+        userId: stored.userId,
+        projectId: stored.projectId,
+        apiKey: stored.apiKey,
+        avatarId: stored.avatarId
+      });
+    }
+    const projectId = stored.projectId || connected.projectId;
+    const userId = stored.userId || connected.userId;
+    printHeader("Asiyst Project Status");
+    printProjectSummary(detectProject(cwd), true, connected.projectName, connected.website);
+    console.log(`
+${section("Identifiers")}`);
+    if (userId) console.log(`  User ID: ${maskSecret(userId)}`);
+    console.log(`  Project ID: ${projectId}`);
+    console.log(`  API Key: ${maskSecret(stored.apiKey)}`);
     console.log(`
-Project ID: ${result.project.projectId}
-Public Key: ${result.project.publicKey || project.config.publicKey || "Use the public key from the Asiyst project settings."}`);
+${section("Integration")}`);
+    console.log(`  User: ${success(symbols.success)} Connected`);
+    console.log(`  Project: ${success(symbols.success)} ${connected.projectName ?? projectId}`);
+    if (stored.avatarId) console.log(`  Avatar: ${success(symbols.success)} ${stored.avatarName ?? stored.avatarId}`);
+    else console.log(`  Avatar: ${symbols.error} Not imported`);
+    const detection = detectProject(cwd);
+    console.log(`  SDK: ${detection.sdkVersion ? `${success(symbols.success)} Installed (${detection.sdkVersion})` : `${symbols.error} Not installed`}`);
+    console.log(`  Integration: ${detection.sdkVersion && stored.avatarId ? `${success(symbols.success)} Configured` : `${symbols.error} Not configured`}`);
+    console.log(`
+${success(symbols.success)} Everything looks good.`);
+  } catch (error) {
+    if (error instanceof ApiError && error.code === "API_KEY_REVOKED") {
+      console.log("\u2717 API key revoked.");
+      console.log("Create a new key from:\nhttps://asiyst.com");
+      return;
+    }
+    if (error instanceof ApiError && (error.code === "INVALID_API_KEY" || error.code === "FORBIDDEN")) {
+      console.log(`${symbols.error} Connection invalid. Run \`asiyst connect\` to reconnect.`);
+      return;
+    }
+    console.log(`${symbols.error} Connection invalid. Run \`asiyst doctor\` for diagnostics.`);
   }
-  const warning = configWarning(cwd);
-  if (warning) console.log(`
-Warning: ${warning}`);
-  console.log('\nUse the public SDK API:\n\nimport { Asiyst } from "@asiyst/sdk";\n\nawait Asiyst.init({ projectId: "PROJECT_ID", publicKey: "PUBLIC_KEY" });');
-  console.log("\nRun `npx asiyst verify` after starting your website.");
 }
 
-// src/commands/login.ts
-async function loginCommand(api = new ApiClient()) {
-  await connect(api);
-  console.log("\u2713 Already connected to Asiyst.");
+// src/api/projects.ts
+async function verifyInstallation(api, projectId, publicKey, domain) {
+  const value = await api.request("/cli/verification", {
+    method: "POST",
+    body: JSON.stringify({ projectId, publicKey, domain })
+  });
+  if (!Array.isArray(value) || !value.every((item) => item && typeof item === "object" && typeof item.name === "string" && typeof item.ok === "boolean")) {
+    throw new ApiError("Received an unexpected response from Asiyst.", 200, "MALFORMED_RESPONSE");
+  }
+  return value;
 }
-
-// src/commands/logout.ts
-function logoutCommand() {
-  console.log("\u2713 Local CLI session information removed (the CLI does not store passwords or private credentials).");
+function requireIdentifier(value, name, valid) {
+  const trimmed = value.trim();
+  if (!valid(trimmed)) throw new ApiError(`Invalid ${name}.`, 400, "INVALID_REQUEST");
+  return trimmed;
 }
-
-// src/commands/status.ts
-async function statusCommand(cwd = process.cwd(), api = new ApiClient()) {
-  const project = detectProject(cwd);
-  console.log(`Project: ${typeof project.packageJson?.name === "string" ? project.packageJson.name : "Unknown"}
-SDK: ${project.sdkVersion || "Not connected"}`);
-  if (!project.config.projectId || !project.config.publicKey) {
-    console.log("\nProject: Not connected\nSDK: Not connected\nAvatar: Not configured\n\nStatistics:\nConnect your website to show stats.");
-    return;
+function parseAvatarImportResponse(value, projectId, userId, avatarId) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) {
+    throw new ApiError("Received an unexpected response from Asiyst.", 200, "MALFORMED_RESPONSE");
   }
-  const info = await api.projectInfo(project.config.projectId);
-  console.log(`
-Project: ${info.connectionStatus || "Connected"}
-SDK: ${project.sdkVersion}
-Avatar: ${info.avatarStatus || "Not configured"}`);
-  console.log("\nStatistics:");
-  console.log(info.lastSdkConnection ? `Last SDK heartbeat: ${info.lastSdkConnection}` : "No SDK heartbeat recorded.");
+  const response = value;
+  const body = response.data && typeof response.data === "object" && !Array.isArray(response.data) ? response.data : response;
+  const imported = body.imported === true || body.success === true || body.status === "imported";
+  const alreadyImported = body.code === "AVATAR_ALREADY_IMPORTED" || body.status === "already_imported";
+  if (alreadyImported) {
+    return {
+      imported: true,
+      alreadyImported: true,
+      avatarId,
+      projectId,
+      userId,
+      avatarName: typeof body.avatarName === "string" ? body.avatarName : void 0,
+      publicKey: typeof body.publicKey === "string" ? body.publicKey : void 0
+    };
+  }
+  if (!imported) {
+    const code = typeof body.code === "string" ? body.code : "IMPORT_FAILED";
+    const supportedCode = ["AVATAR_NOT_FOUND", "AVATAR_ALREADY_IMPORTED", "FORBIDDEN", "PROJECT_NOT_FOUND", "CONFLICT"].includes(code) ? code : "IMPORT_FAILED";
+    throw new ApiError(typeof body.message === "string" ? body.message : "Avatar import was not completed.", 200, supportedCode);
+  }
+  const returnedAvatarId = body.avatarId ?? body.avatar_id;
+  if (returnedAvatarId !== void 0 && returnedAvatarId !== avatarId) {
+    throw new ApiError("The API returned a different avatar than requested.", 200, "AVATAR_MISMATCH");
+  }
+  const returnedProjectId = body.projectId ?? body.project_id;
+  if (returnedProjectId !== void 0 && returnedProjectId !== projectId) {
+    throw new ApiError("The API returned a different project than requested.", 200, "PROJECT_MISMATCH");
+  }
+  const returnedUserId = body.userId ?? body.user_id;
+  if (returnedUserId !== void 0 && returnedUserId !== userId) {
+    throw new ApiError("The API returned a different user than requested.", 200, "USER_MISMATCH");
+  }
+  return {
+    imported: true,
+    avatarId,
+    projectId,
+    userId,
+    avatarName: typeof body.avatarName === "string" ? body.avatarName : void 0,
+    publicKey: typeof body.publicKey === "string" ? body.publicKey : void 0
+  };
+}
+async function importAvatar(api, input) {
+  const userId = requireIdentifier(input.userId, "User ID", isValidUserId);
+  const projectId = requireIdentifier(input.projectId, "Project ID", isValidProjectId);
+  const avatarId = requireIdentifier(input.avatarId, "Avatar ID", isValidAvatarId);
+  const apiKey = input.apiKey.trim();
+  if (!isValidApiKey(apiKey)) throw new ApiError("Invalid API key. It must be exactly 32 characters.", 401, "INVALID_API_KEY");
+  const value = await api.request(`/cli/projects/${encodeURIComponent(projectId)}/avatars/import`, {
+    method: "POST",
+    headers: {
+      Authorization: "Bearer " + apiKey,
+      "X-Asiyst-API-Key": apiKey
+    },
+    body: JSON.stringify({ userId, projectId, avatarId })
+  });
+  return parseAvatarImportResponse(value, projectId, userId, avatarId);
 }
 
 // src/commands/verify.ts
-async function verifyCommand(cwd = process.cwd(), api = new ApiClient()) {
+function printVerificationSafe(results) {
+  console.log("\nAsiyst Installation Verification\n");
+  for (const result of results) result.ok ? ok(result.name, result.detail) : fail(result.name, result.detail);
+  return results.length > 0 && results.every((result) => result.ok);
+}
+async function verifyCommand(cwd = process.cwd()) {
   const project = detectProject(cwd);
   if (!project.packageJson) {
     fail("Project detected", "package.json is missing");
@@ -457,105 +1243,514 @@ async function verifyCommand(cwd = process.cwd(), api = new ApiClient()) {
     return;
   }
   ok("Project detected");
-  if (!project.sdkVersion) {
-    fail("SDK installed", "npm install @asiyst/sdk");
-    process.exitCode = 1;
-    return;
-  }
-  ok("SDK installed", project.sdkVersion);
-  if (!project.config.projectId || !project.config.publicKey) {
-    fail("Configuration found", "set ASIIYST_PROJECT_ID and ASIIYST_PUBLIC_KEY");
+  const stored = await loadConnection(cwd);
+  if (!stored) {
+    fail("Configuration found", "run asiyst connect");
     process.exitCode = 1;
     return;
   }
   ok("Configuration found");
   try {
-    const results = await api.verify(project.config.projectId, project.config.publicKey, process.env.ASIIYST_DOMAIN);
-    if (!printVerification(results)) process.exitCode = 1;
+    const results = await verifyInstallation(createApiClient(), stored.projectId, stored.publicKey || "", process.env.ASIIYST_DOMAIN);
+    if (!printVerificationSafe(results)) process.exitCode = 1;
   } catch (error) {
     fail("API reachable", error instanceof Error ? error.message : "verification failed");
     process.exitCode = 1;
   }
 }
 
+// src/config/version.ts
+import { readFileSync as readFileSync5 } from "fs";
+import { fileURLToPath } from "url";
+function readCurrentVersion() {
+  if ("1.1.2") return "1.1.2";
+  try {
+    const packageJson = JSON.parse(readFileSync5(fileURLToPath(new URL("../package.json", import.meta.url)), "utf8"));
+    if (packageJson && typeof packageJson === "object" && typeof packageJson.version === "string") {
+      return packageJson.version;
+    }
+  } catch {
+  }
+  try {
+    const packageJson = JSON.parse(readFileSync5(fileURLToPath(new URL("../../package.json", import.meta.url)), "utf8"));
+    if (packageJson && typeof packageJson === "object" && typeof packageJson.version === "string" && packageJson.name === "@asiyst/cli") {
+      return packageJson.version;
+    }
+  } catch {
+  }
+  return "0.0.0";
+}
+
 // src/commands/doctor.ts
-async function doctorCommand(cwd = process.cwd(), api = new ApiClient()) {
-  const project = detectProject(cwd);
+async function doctorCommand(cwd = process.cwd(), api = createApiClient()) {
+  ok("CLI version", readCurrentVersion());
+  ok("Executable", process.argv[1] || "unknown");
+  ok("API base", api.baseUrl || CLI_API_BASE_URL);
+  ok("Verify endpoint", VERIFY_KEY_URL);
   ok("System", process.platform);
   ok("Node.js", process.version);
-  ok("npm", "available through npm");
+  const project = detectProject(cwd);
   project.packageJson ? ok("Project", cwd) : fail("Project", "package.json is missing");
   project.sdkVersion ? ok("SDK", project.sdkVersion) : fail("SDK", "not installed");
-  project.config.projectId && project.config.publicKey ? ok("Configuration") : fail("Configuration", "public project values are missing");
+  const stored = await loadConnection(cwd);
+  stored ? ok("Local credential", "present") : fail("Local credential", "not connected");
   try {
     await api.health();
-    ok("Asiyst API", "HTTPS health endpoint reachable");
+    ok("Asiyst API", "health endpoint reachable");
   } catch (error) {
     fail("Asiyst API", error instanceof Error ? error.message : "unreachable");
   }
-  if (project.config.projectId && project.config.publicKey) {
-    try {
-      await api.projectInfo(project.config.projectId);
-      ok("Project connection");
-    } catch (error) {
-      fail("Project connection", error instanceof Error ? error.message : "unavailable");
-    }
-  }
 }
 
 // src/commands/dashboard.ts
 async function dashboardCommand() {
-  const configured = process.env.ASIIYST_DASHBOARD_URL || `${ASIIYST_WEB_URL}/dashboard`;
-  const parsed = new URL(configured);
-  if (parsed.protocol !== "https:") throw new Error("Configured dashboard URL must use HTTPS.");
-  const url = parsed.toString();
-  if (!await openBrowser(url)) console.log(`Open ${url}`);
+  const url = ASIIYST_WEB_URL;
+  if (!await openBrowser(url)) console.log(`Open this URL manually:
+${url}`);
   else console.log(`Opening ${url}`);
 }
 
+// src/integration/writer.ts
+import { execFile as execFile3 } from "child_process";
+import { existsSync as existsSync5, mkdirSync as mkdirSync4, readFileSync as readFileSync6, writeFileSync as writeFileSync4 } from "fs";
+import { dirname, join as join4, relative, resolve as resolve5 } from "path";
+import { promisify as promisify3 } from "util";
+var execFileAsync3 = promisify3(execFile3);
+var MARKER_START = "// ASIIYST CLI START";
+var MARKER_END = "// ASIIYST CLI END";
+function componentSource(values, extension) {
+  if (extension === "ts" || extension === "js") {
+    return `${MARKER_START}
+import { Asiyst } from "@asiyst/sdk";
+
+void Asiyst.init({
+  projectId: ${JSON.stringify(values.projectId)},
+  publicKey: ${JSON.stringify(values.publicKey)},
+  avatarId: ${JSON.stringify(values.avatarId)},
+  position: "bottom-right",
+});
+${MARKER_END}
+`;
+  }
+  const importLine = extension === "tsx" ? 'import * as React from "react";' : 'import React from "react";';
+  return `${MARKER_START}
+${importLine}
+import { Asiyst } from "@asiyst/sdk";
+
+let asiystStarted = false;
+
+export function AsiystAssistant() {
+  React.useEffect(() => {
+    if (asiystStarted) return;
+    asiystStarted = true;
+    void Asiyst.init({
+      projectId: ${JSON.stringify(values.projectId)},
+      publicKey: ${JSON.stringify(values.publicKey)},
+      avatarId: ${JSON.stringify(values.avatarId)},
+      position: "bottom-right",
+    }).catch((error) => {
+      asiystStarted = false;
+      console.error("Asiyst failed to initialize.", error);
+    });
+  }, []);
+
+  return null;
+}
+${MARKER_END}
+`;
+}
+function read(path) {
+  return readFileSync6(path, "utf8");
+}
+function findFirst(cwd, paths) {
+  return paths.map((path) => resolve5(cwd, path)).find((path) => existsSync5(path));
+}
+function isTypeScript(project) {
+  return project.language === "TypeScript" || existsSync5(resolve5(project.cwd, "tsconfig.json"));
+}
+function pathsFor(project) {
+  if (project.framework === "Vanilla TypeScript" || project.framework === "Vanilla JavaScript") {
+    const extension2 = project.framework === "Vanilla TypeScript" ? "ts" : "js";
+    return {
+      component: join4("src", `asiyst.${extension2}`),
+      entry: findFirst(project.cwd, [`src/index.${extension2}`, `index.${extension2}`]),
+      extension: extension2
+    };
+  }
+  const extension = isTypeScript(project) ? "tsx" : "jsx";
+  const component = join4("src", "components", `AsiystAssistant.${extension}`);
+  if (project.framework === "Next.js") {
+    const appEntry = findFirst(project.cwd, ["src/app/layout.tsx", "src/app/layout.jsx", "app/layout.tsx", "app/layout.jsx"]);
+    if (appEntry) return { component, entry: appEntry, extension: appEntry.endsWith(".tsx") ? "tsx" : "jsx" };
+    const pagesEntry = findFirst(project.cwd, ["src/pages/_app.tsx", "src/pages/_app.jsx", "pages/_app.tsx", "pages/_app.jsx"]);
+    if (pagesEntry) return { component, entry: pagesEntry, extension: pagesEntry.endsWith(".tsx") ? "tsx" : "jsx" };
+    return { component, extension };
+  }
+  const entry = findFirst(project.cwd, [
+    "src/main.tsx",
+    "src/main.jsx",
+    "src/main.ts",
+    "src/main.js",
+    "src/index.tsx",
+    "src/index.jsx",
+    "src/index.ts",
+    "src/index.js"
+  ]);
+  return { component, entry, extension: entry?.endsWith(".tsx") || entry?.endsWith(".ts") ? "tsx" : "jsx" };
+}
+function updateComponent(path, source, values) {
+  if (!existsSync5(path)) {
+    mkdirSync4(dirname(path), { recursive: true });
+    writeFileSync4(path, source, "utf8");
+    return "create";
+  }
+  const current = read(path);
+  const start = current.indexOf(MARKER_START);
+  const end = current.indexOf(MARKER_END);
+  if (start >= 0 && end >= start) {
+    const next2 = current.slice(0, start) + source.trimEnd() + current.slice(end + MARKER_END.length);
+    if (next2 === current) return "unchanged";
+    writeFileSync4(path, next2, "utf8");
+    return "update";
+  }
+  const replacements = {
+    projectId: JSON.stringify(values.projectId),
+    publicKey: JSON.stringify(values.publicKey),
+    avatarId: JSON.stringify(values.avatarId)
+  };
+  let next = source;
+  for (const [name, value] of Object.entries(replacements)) {
+    const pattern = new RegExp(`(${name}\\s*:\\s*)["'\`][^"'\`]+["'\`]`);
+    if (!pattern.test(next)) {
+      throw new Error(`Existing Asiyst component is not safely updateable: ${path}`);
+    }
+    next = next.replace(pattern, `$1${value}`);
+  }
+  if (next === source) return "unchanged";
+  writeFileSync4(path, next, "utf8");
+  return "update";
+}
+function updateEntry(path, componentPath) {
+  const current = read(path);
+  const importPath = relative(dirname(path), resolve5(componentPath)).replace(/\\/g, "/").replace(/\.(tsx|jsx)$/, "").replace(/^\.\//, "");
+  const importLine = componentPath.endsWith(".ts") || componentPath.endsWith(".js") ? `import "./${importPath}";` : `import { AsiystAssistant } from "./${importPath}";`;
+  const hasImport = current.includes("AsiystAssistant") && current.includes("@asiyst/sdk");
+  const nextImport = hasImport ? current : `${importLine}
+${current}`;
+  const componentPattern = /<AsiystAssistant\s*\/>/;
+  let next = componentPattern.test(nextImport) ? nextImport : nextImport;
+  if (!componentPattern.test(nextImport)) {
+    if (/\{children\}/.test(nextImport)) {
+      next = nextImport.replace(/\{children\}/, "<AsiystAssistant />\n        {children}");
+    } else if (/<App\s*\/>/.test(nextImport)) {
+      next = nextImport.replace(/<App\s*\/>/, "<><AsiystAssistant /><App /></>");
+    } else if (/<Component\s+\{\.\.\.pageProps\}\s*\/>/.test(nextImport)) {
+      next = nextImport.replace(/<Component\s+\{\.\.\.pageProps\}\s*\/>/, "<><AsiystAssistant /><Component {...pageProps} /></>");
+    } else if (componentPath.endsWith(".ts") || componentPath.endsWith(".js")) {
+      next = nextImport;
+    } else {
+      throw new Error(`Could not find a safe render location in ${path}. Add <AsiystAssistant /> to this entry point.`);
+    }
+  }
+  if (next === current) return "unchanged";
+  writeFileSync4(path, next, "utf8");
+  return "update";
+}
+function planIntegration(project, values) {
+  if (!values.projectId || !values.publicKey || !values.avatarId) {
+    throw new Error("Verified projectId, publicKey, and avatarId are required before configuring the SDK.");
+  }
+  const paths = pathsFor(project);
+  const componentPath = resolve5(project.cwd, paths.component);
+  const entryPath = paths.entry;
+  if (!entryPath && !project.framework.startsWith("Vanilla") && project.framework !== "Next.js" && project.framework !== "React" && project.framework !== "Vite") {
+    return {
+      framework: project.framework,
+      sdkInstalled: Boolean(project.sdkVersion),
+      sdkVersion: project.sdkVersion,
+      componentPath,
+      componentAction: existsSync5(componentPath) ? "update" : "create",
+      entryAction: "unsupported",
+      reason: "No supported React entry point was detected. Add AsiystAssistant to the website entry point manually."
+    };
+  }
+  return {
+    framework: project.framework,
+    sdkInstalled: Boolean(project.sdkVersion),
+    sdkVersion: project.sdkVersion,
+    componentPath,
+    entryPath,
+    componentAction: existsSync5(componentPath) ? "update" : "create",
+    entryAction: entryPath ? "update" : "unsupported",
+    reason: entryPath ? void 0 : "No supported application entry point was detected."
+  };
+}
+async function installSdk(project) {
+  const commands = {
+    npm: { command: "npm", args: ["install", "@asiyst/sdk"] },
+    pnpm: { command: "pnpm", args: ["add", "@asiyst/sdk"] },
+    yarn: { command: "yarn", args: ["add", "@asiyst/sdk"] },
+    bun: { command: "bun", args: ["add", "@asiyst/sdk"] }
+  };
+  const selected = commands[project.packageManager] ?? commands.npm;
+  await execFileAsync3(selected.command, selected.args, { cwd: project.cwd, windowsHide: true });
+}
+function applyIntegration(project, values, plan = planIntegration(project, values)) {
+  if (plan.entryAction === "unsupported" || !plan.entryPath) {
+    throw new Error(plan.reason ?? "The project entry point could not be detected safely.");
+  }
+  const paths = pathsFor(project);
+  const componentAction = updateComponent(plan.componentPath, componentSource(values, paths.extension), values);
+  const entryAction = updateEntry(plan.entryPath, plan.componentPath);
+  return { ...plan, componentAction, entryAction, installed: plan.sdkInstalled };
+}
+function printDryRun(plan) {
+  console.log(`Framework: ${plan.framework}`);
+  console.log(`SDK: ${plan.sdkInstalled ? `installed${plan.sdkVersion ? ` (${plan.sdkVersion})` : ""}` : "missing"}`);
+  console.log(`Component: ${plan.componentAction} ${plan.componentPath}`);
+  console.log(`Entry point: ${plan.entryPath ? `${plan.entryAction} ${plan.entryPath}` : "not detected"}`);
+  if (plan.reason) console.log(`Note: ${plan.reason}`);
+}
+function readIntegrationValues(plan) {
+  if (!existsSync5(plan.componentPath)) return {};
+  const source = read(plan.componentPath);
+  const value = (name) => {
+    const match = source.match(new RegExp(`${name}\\s*:\\s*["'\`]([^"'\`]+)["'\`]`));
+    return match?.[1];
+  };
+  return {
+    projectId: value("projectId"),
+    publicKey: value("publicKey"),
+    avatarId: value("avatarId")
+  };
+}
+
 // src/commands/avatar.ts
-async function avatarCommand(cwd = process.cwd(), api = new ApiClient()) {
+function parseAvatarId(argv) {
+  const index = argv.findIndex((value) => value === "--avatar-id");
+  if (index >= 0) return argv[index + 1];
+  const inline = argv.find((value) => value.startsWith("--avatar-id="));
+  return inline?.slice("--avatar-id=".length) || argv.slice(1).find((value) => !value.startsWith("--"));
+}
+async function confirm2(message) {
+  const result = await selectOption(message, [
+    { label: "Continue", value: true },
+    { label: "Cancel", value: false }
+  ]);
+  return result.type === "selected" && result.value;
+}
+async function avatarImportCommand(cwd = process.cwd(), api = createApiClient(), suppliedAvatarId) {
+  const stored = await loadConnection(cwd);
+  if (!stored?.apiKey || !stored.userId || !stored.projectId) {
+    console.log("No project is connected. Please run:\nasiyst connect");
+    return;
+  }
+  const avatarId = suppliedAvatarId ?? await readInput("Enter your Avatar ID: ");
+  if (!avatarId || !isValidAvatarId(avatarId)) {
+    console.log("Invalid Avatar ID. It must contain exactly 10 alphanumeric characters.");
+    return;
+  }
+  console.log("Opening Asiyst Avatar Studio...");
+  if (!await openBrowser(ASIIYST_WEB_URL)) {
+    console.log(`Open this URL manually:
+${ASIIYST_WEB_URL}`);
+  }
+  console.log("Configure and save your avatar in Avatar Studio, then return here.");
   const project = detectProject(cwd);
-  if (!project.config.projectId) {
-    console.log("Avatar\n\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\nNo avatar configured.\n\nCreate your avatar in the Asiyst dashboard.");
-    const url = `${ASIIYST_WEB_URL}/dashboard`;
+  const dryRun = process.argv.includes("--dry-run");
+  const detectedProjectId = project.config.projectId;
+  if (detectedProjectId && detectedProjectId !== stored.projectId) {
+    console.log(`Existing projectId ${detectedProjectId} differs from verified project ${stored.projectId}.`);
+    if (!await confirm2("Switch this website to the verified project?")) return;
+  }
+  const existingPlan = planIntegration(project, {
+    projectId: stored.projectId,
+    publicKey: stored.publicKey ?? "pending-public-key",
+    avatarId: avatarId.trim()
+  });
+  const existing = readIntegrationValues(existingPlan);
+  if (existing.projectId && existing.projectId !== stored.projectId) {
+    console.log(`\u2717 Existing integration uses project ${existing.projectId}, but the verified project is ${stored.projectId}.`);
+    if (!await confirm2("Replace the existing project configuration?")) return;
+  }
+  if (existing.avatarId && existing.avatarId !== avatarId.trim()) {
+    console.log(`\u2717 Existing integration uses avatar ${existing.avatarId}, but the verified avatar is ${avatarId.trim()}.`);
+    if (!await confirm2("Replace the existing avatar configuration?")) return;
+  }
+  try {
+    if (dryRun) {
+      const plan2 = planIntegration(project, {
+        projectId: stored.projectId,
+        publicKey: stored.publicKey ?? "",
+        avatarId: avatarId.trim()
+      });
+      printDryRun(plan2);
+      return;
+    }
+    const verifiedConnection = await verifyApiKeyRelationship(api, {
+      userId: stored.userId,
+      projectId: stored.projectId,
+      apiKey: stored.apiKey
+    });
+    await verifyAvatar(api, {
+      userId: stored.userId,
+      projectId: stored.projectId,
+      apiKey: stored.apiKey,
+      avatarId
+    });
+    await createImportSession(api, {
+      userId: stored.userId,
+      projectId: stored.projectId,
+      apiKey: stored.apiKey,
+      avatarId
+    });
+    const shouldImport = await confirm2("Import this avatar into this website?");
+    if (!shouldImport) {
+      console.log("Avatar import cancelled. Your verified connection has been saved.");
+      return;
+    }
+    const result = await importAvatar(api, {
+      userId: stored.userId,
+      projectId: stored.projectId,
+      apiKey: stored.apiKey,
+      avatarId
+    });
+    const publicKey = stored.publicKey ?? verifiedConnection.publicKey ?? result.publicKey;
+    if (!publicKey) {
+      console.log("\u2717 The verified project did not return a public SDK key. No files were changed.");
+      return;
+    }
+    const plan = planIntegration(detectProject(cwd), {
+      projectId: result.projectId,
+      publicKey,
+      avatarId: result.avatarId
+    });
+    if (!plan.sdkInstalled) {
+      console.log(`Installing @asiyst/sdk with ${project.packageManager}...`);
+      await installSdk(project);
+    }
+    const configured = applyIntegration(detectProject(cwd), {
+      projectId: result.projectId,
+      publicKey,
+      avatarId: result.avatarId
+    });
+    const next = { ...stored, avatarId: result.avatarId, avatarName: result.avatarName, publicKey };
+    await saveConnection(cwd, next);
+    writeProjectMetadata(cwd, next);
+    console.log("\u2713 Avatar verified");
+    console.log("\u2713 Project verified");
+    console.log("\u2713 API key verified");
+    console.log("\u2713 SDK installed");
+    console.log(`\u2713 Asiyst integration ${configured.componentAction === "unchanged" ? "already " : ""}configured`);
+    console.log(`\u2713 Avatar ${result.alreadyImported ? "already imported" : "imported"}`);
+    console.log(`
+Your Asiyst avatar is ready.`);
+  } catch (error) {
+    if (error instanceof ApiError) {
+      if (error.code === "FORBIDDEN") console.log("\u2717 You do not have permission to import an avatar into this project.");
+      else if (error.code === "USER_MISMATCH") console.log("\u2717 The avatar is not owned by the verified Asiyst user.");
+      else if (error.code === "PROJECT_MISMATCH") console.log("\u2717 The avatar is not assigned to the verified project.");
+      else if (error.code === "NOT_FOUND") console.log("\u2717 Project or avatar was not found.");
+      else if (error.code === "CONFLICT" || error.code === "AVATAR_ALREADY_IMPORTED") console.log("\u2717 This avatar is already imported into the project.");
+      else console.log(`\u2717 ${error.message}`);
+      return;
+    }
+    console.log(`\u2717 ${error instanceof Error ? error.message : "Unable to import the avatar."}`);
+  }
+}
+async function avatarCommand(cwd = process.cwd(), argv = process.argv.slice(2)) {
+  if (argv[0] === "import") {
+    await avatarImportCommand(cwd, createApiClient(), parseAvatarId(argv));
+    return;
+  }
+  const stored = await loadConnection(cwd);
+  if (!stored) {
+    console.log("Connect your project to Asiyst to view avatar information.");
+    const url = ASIIYST_WEB_URL;
     if (await openBrowser(url)) console.log(`Opening ${url}`);
-    else console.log(`Open ${url}`);
+    else console.log(`Open this URL manually:
+${url}`);
     return;
   }
-  const info = await api.projectInfo(project.config.projectId);
-  console.log(`Avatar
-\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500
-Status        ${info.avatarStatus || "Not configured"}
-
-Configure your avatar in the Asiyst dashboard.`);
+  console.log(`Avatar configuration is managed at ${ASIIYST_WEB_URL}.`);
+  if (!await openBrowser(ASIIYST_WEB_URL)) console.log(`Open this URL manually:
+${ASIIYST_WEB_URL}`);
 }
 
-// src/update/check.ts
-import { execFileSync } from "child_process";
-import { readFileSync as readFileSync5 } from "fs";
+// src/commands/interactive.ts
+import { stdin as stdin3, stdout as stdout4 } from "process";
+import { emitKeypressEvents as emitKeypressEvents3 } from "readline";
 
-// src/config/version.ts
-import { readFileSync as readFileSync4 } from "fs";
-import { fileURLToPath } from "url";
-function readCurrentVersion() {
-  for (const packageUrl of [
-    new URL("../package.json", import.meta.url),
-    new URL("../../package.json", import.meta.url),
-    new URL("../../../package.json", import.meta.url)
-  ]) {
-    try {
-      const packageJson = JSON.parse(readFileSync4(fileURLToPath(packageUrl), "utf8"));
-      if (packageJson && typeof packageJson === "object" && typeof packageJson.version === "string") {
-        return packageJson.version;
-      }
-    } catch {
+// src/commands/health.ts
+async function healthCommand(api = createApiClient(), cwd = process.cwd()) {
+  printHeader("Asiyst Health Check");
+  const project = detectProject(cwd);
+  let healthy = true;
+  ok("Project detected", project.framework);
+  if (project.sdkVersion) ok("SDK installed", project.sdkVersion);
+  else {
+    fail("SDK installed", "Run the avatar import command to install it");
+    healthy = false;
+  }
+  try {
+    await api.health();
+    ok("Asiyst API reachable");
+  } catch {
+    fail("Asiyst API reachable", "Unable to reach Asiyst API");
+    console.log(`
+Health: ${warning(symbols.warning)} Action required`);
+    return;
+  }
+  const stored = await loadConnection(cwd);
+  if (!stored?.apiKey || !stored.userId || !stored.projectId) {
+    console.log(`
+Health: ${warning(symbols.warning)} Action required`);
+    console.log("Run `asiyst connect` to connect this project.");
+    return;
+  }
+  ok("Authentication valid");
+  try {
+    await verifyApiKeyRelationship(api, {
+      userId: stored.userId,
+      projectId: stored.projectId,
+      apiKey: stored.apiKey
+    });
+    ok("Project authorized");
+    const metadata = readProjectMetadata(cwd);
+    if (metadata?.avatarId) {
+      await verifyAvatar(api, {
+        userId: stored.userId,
+        projectId: stored.projectId,
+        apiKey: stored.apiKey,
+        avatarId: metadata.avatarId
+      });
+      ok("Avatar verified", metadata.avatarName ?? metadata.avatarId);
+    } else {
+      fail("Avatar", "No imported avatar is recorded for this project");
+      healthy = false;
+    }
+    if (metadata?.projectId === stored.projectId && metadata.publicKey) ok("Local configuration", "Project and public key present");
+    else {
+      fail("Local configuration", "Project metadata is incomplete");
+      healthy = false;
     }
+    if (project.sdkVersion && metadata?.avatarId) ok("Website integration", "SDK and avatar are configured");
+    else {
+      fail("Website integration", "Run `asiyst avatar import`");
+      healthy = false;
+    }
+    console.log(`
+Health: ${healthy ? `${success(symbols.connected)} Healthy` : `${warning(symbols.warning)} Action required`}`);
+  } catch {
+    fail("Project authorization", "Run `asiyst connect` to reconnect");
+    console.log(`
+Health: ${warning(symbols.warning)} Action required`);
   }
-  return "0.2.0";
 }
 
 // src/update/check.ts
+import { execFileSync } from "child_process";
+import { readFileSync as readFileSync7 } from "fs";
 var PACKAGE_NAME = "@asiyst/cli";
 var REGISTRY_URL = "https://registry.npmjs.org/%40asiyst%2Fcli/latest";
 var TIMEOUT_MS = 800;
@@ -627,7 +1822,7 @@ function detectInstallKind(executablePath = process.argv[1] ?? "", env = process
 }
 function installedVersion(packageRoot) {
   try {
-    const value = JSON.parse(readFileSync5(`${packageRoot}/package.json`, "utf8"));
+    const value = JSON.parse(readFileSync7(`${packageRoot}/package.json`, "utf8"));
     return value && typeof value === "object" && typeof value.version === "string" ? value.version : void 0;
   } catch {
     return void 0;
@@ -650,18 +1845,18 @@ function installLatest(latestVersion, kind, executablePath = process.argv[1] ??
 
 // src/commands/update.ts
 async function updateCommand() {
+  printHeader("Asiyst CLI Update");
   const result = await checkForUpdate();
   if (!result.latestVersion || compareVersions(result.latestVersion, result.currentVersion) <= 0) {
-    console.log(`\u2713 Asiyst CLI is already up to date.
+    console.log(`${success(symbols.success)} Latest version
 
 Current version: ${result.currentVersion}`);
     return;
   }
-  console.log(`
-Update available
+  console.log(`${warning(symbols.warning)} Update available
 
 Current version: ${result.currentVersion}
-New version: ${result.latestVersion}
+Latest version: ${result.latestVersion}
 `);
   if (!process.stdin.isTTY || !await confirm(`Update Asiyst CLI from ${result.currentVersion} to ${result.latestVersion}?`)) {
     console.log("Update cancelled.");
@@ -678,7 +1873,7 @@ New version: ${result.latestVersion}
     if (!installed || compareVersions(installed, result.latestVersion) !== 0) {
       throw new Error("installed version could not be verified");
     }
-    console.log(`\u2713 Verifying installation
+    console.log(`${success(symbols.success)} Verifying installation
 
 Asiyst CLI updated from ${result.currentVersion} to ${installed}.
 Restart Asiyst to use the new version.`);
@@ -689,101 +1884,253 @@ ${error instanceof Error ? error.message : "Installation could not be verified."
 }
 
 // src/commands/interactive.ts
-function resolveInput(value) {
-  const input = value.trim().toLowerCase();
-  if (/^(connect|connect my website|connect this website|connect website|init)/.test(input)) return "connect";
-  if (/^(status|check status|check .*installation)/.test(input)) return "status";
-  if (/diagnos|doctor/.test(input)) return "diagnostics";
-  if (/dashboard/.test(input)) return "dashboard";
-  if (/avatar|configure my avatar|create avatar/.test(input)) return "avatar";
-  if (/update|upgrade/.test(input)) return "update";
-  if (/^(help|\?)$/.test(input)) return "help";
-  if (/^(version|--version)$/.test(input)) return "version";
-  return input;
-}
 function interactiveHelp() {
-  console.log("\nASIYST CLI\n\nUsage: asiyst [command]\n\nCommands\n  connect       Connect this project to Asiyst\n  status        Show project and Asiyst status\n  diagnostics   Run diagnostics\n  dashboard     Open Asiyst dashboard\n  avatar        Configure avatar\n  update        Check for and install CLI updates\n  help          Show available commands\n  version       Show CLI version\n  trust         Trust this project folder\n  revoke-trust  Revoke folder trust\n  logout        Remove local CLI session information\n\nExamples\n  asiyst connect\n  asiyst status\n  asiyst update");
+  console.log(`
+Asiyst CLI
+
+Usage: asiyst [command]
+
+Commands
+  connect       Connect this project to Asiyst
+  status        Show connection status
+  avatar        Manage and import avatars
+  health        Check Asiyst API connectivity
+  disconnect    Remove local connection information
+  help          Show available commands
+  version       Show CLI version
+
+Also available
+  trust         Trust this project folder
+  revoke-trust  Revoke folder trust
+  doctor        Run diagnostics
+  update        Check for CLI updates
+
+Examples
+  asiyst connect
+  asiyst status
+  asiyst health
+  asiyst avatar import
+  asiyst avatar import <avatar-id>
+  asiyst disconnect
+`);
 }
-async function interactiveHome() {
-  homeStatus(detectProject());
-  console.log("\nWelcome to Asiyst CLI.\nUse UP/DOWN to select a command, or type a command.\n");
-  const suggestions = [
-    { label: "Connect this project", value: "connect" },
-    { label: "Check project status", value: "status" },
-    { label: "Run diagnostics", value: "diagnostics" },
-    { label: "Open dashboard", value: "dashboard" },
-    { label: "Configure avatar", value: "avatar" },
-    { label: "Update CLI", value: "update" },
-    { label: "Help", value: "help" },
-    { label: "Exit", value: "exit" }
+var COMMANDS = [
+  { input: "connect", label: "Connect this project to Asiyst" },
+  { input: "status", label: "Show connection status" },
+  { input: "avatar", label: "Manage avatars" },
+  { input: "avatar import", label: "Import an avatar" },
+  { input: "health", label: "Check Asiyst API health" },
+  { input: "disconnect", label: "Disconnect this project" },
+  { input: "help", label: "Show available commands" },
+  { input: "version", label: "Show CLI version" },
+  { input: "update", label: "Check for CLI updates" },
+  { input: "exit", label: "Exit the interactive CLI" }
+];
+function suggestions(value) {
+  const query = value.trim().toLowerCase();
+  if (!query) return COMMANDS;
+  return COMMANDS.filter((command) => command.input.startsWith(query));
+}
+function readCommand() {
+  if (!stdin3.isTTY || !stdout4.isTTY) return Promise.resolve(void 0);
+  return new Promise((resolve6) => {
+    let value = "";
+    let active = 0;
+    let settled = false;
+    let renderedLines = 0;
+    const wasRaw = Boolean(stdin3.isRaw);
+    const clear = () => {
+      if (renderedLines === 0) return;
+      stdout4.write(`\x1B[${renderedLines}A\x1B[0J`);
+      renderedLines = 0;
+    };
+    const render = () => {
+      clear();
+      const matches = suggestions(value);
+      if (active >= matches.length) active = Math.max(0, matches.length - 1);
+      const lines = [
+        `${section("Command")} ${value || muted("type a command")}`,
+        "",
+        ...matches.slice(0, 6).map((command, index) => `${index === active ? symbols.pointer : " "} ${command.input.padEnd(18)} ${muted(command.label)}`),
+        "",
+        muted("\u2191\u2193 select  Enter run  Esc cancel  Ctrl+C exit")
+      ];
+      stdout4.write(`${lines.join("\n")}
+`);
+      renderedLines = lines.length;
+    };
+    const finish = (result) => {
+      if (settled) return;
+      settled = true;
+      clear();
+      stdin3.off("keypress", onKeypress);
+      if (stdin3.isTTY) stdin3.setRawMode?.(wasRaw);
+      stdin3.pause();
+      stdout4.write("\n");
+      resolve6(result);
+    };
+    const onKeypress = (chunk, key) => {
+      if (key.ctrl && key.name === "c") {
+        finish(void 0);
+        process.exit(130);
+      }
+      if (key.name === "escape") return finish(void 0);
+      if (key.name === "up") {
+        const matches = suggestions(value);
+        active = Math.max(0, active - 1);
+        if (matches[active]) value = matches[active].input;
+        return render();
+      }
+      if (key.name === "down") {
+        const matches = suggestions(value);
+        active = Math.min(Math.max(0, matches.length - 1), active + 1);
+        if (matches[active]) value = matches[active].input;
+        return render();
+      }
+      if (key.name === "backspace") {
+        value = value.slice(0, -1);
+        active = 0;
+        return render();
+      }
+      if (key.name === "return" || key.name === "enter") {
+        const matches = suggestions(value);
+        const selected = value.trim() || matches[active]?.input;
+        return finish(selected);
+      }
+      if (key.name === "tab") {
+        const matches = suggestions(value);
+        if (matches[active]) value = matches[active].input;
+        return render();
+      }
+      const sequence = key.sequence || chunk;
+      if (sequence && /^[\x20-\x7e]+$/.test(sequence)) {
+        value += sequence;
+        active = 0;
+        return render();
+      }
+      if (key.name === "left" || key.name === "right") return;
+    };
+    emitKeypressEvents3(stdin3);
+    stdin3.setRawMode?.(true);
+    stdin3.resume();
+    stdin3.on("keypress", onKeypress);
+    render();
+  });
+}
+async function runInteractiveCommand(command) {
+  const parts = command.trim().split(/\s+/).filter(Boolean);
+  const root = parts[0];
+  if (root === "exit" || root === "quit") return false;
+  if (root === "connect") await connectCommand();
+  else if (root === "status") await statusCommand();
+  else if (root === "avatar") await avatarCommand(process.cwd(), parts.slice(1));
+  else if (root === "health") await healthCommand();
+  else if (root === "disconnect") await disconnectCommand();
+  else if (root === "help") interactiveHelp();
+  else if (root === "version") console.log(readCurrentVersion());
+  else if (root === "update") await updateCommand();
+  else {
+    console.log(`
+${symbols.error} Unknown command: ${command}`);
+    console.log(`Try ${muted("help")} to see available commands.`);
+  }
+  return true;
+}
+function renderLogo() {
+  const lines = [
+    " \u2588\u2588\u2588\u2588\u2588\u2557 \u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2557\u2588\u2588\u2557\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2557\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2557",
+    "\u2588\u2588\u2554\u2550\u2550\u2550\u2550\u255D \u2588\u2588\u2554\u2550\u2550\u2550\u2550\u255D\u2588\u2588\u2551\u2588\u2588\u2554\u2550\u2550\u2550\u2550\u255D\u255A\u2550\u2550\u2588\u2588\u2554\u2550\u2550\u255D",
+    "\u2588\u2588\u2588\u2588\u2588\u2557   \u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2557\u2588\u2588\u2551\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2557   \u2588\u2588\u2551   ",
+    "\u2588\u2588\u2554\u2550\u2550\u255D   \u255A\u2550\u2550\u2550\u2550\u2588\u2588\u2551\u2588\u2588\u2551\u255A\u2550\u2550\u2550\u2550\u2588\u2588\u2551   \u2588\u2588\u2551   ",
+    "\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2557 \u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2551\u2588\u2588\u2551\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2551   \u2588\u2588\u2551   ",
+    "\u255A\u2550\u2550\u2550\u2550\u2550\u2550\u255D \u255A\u2550\u2550\u2550\u2550\u2550\u2550\u255D\u255A\u2550\u255D\u255A\u2550\u2550\u2550\u2550\u2550\u2550\u255D   \u255A\u2550\u255D   "
   ];
+  console.log(title(lines.join("\n")));
+  console.log();
+}
+function renderWelcome(project, connected) {
+  console.log(muted("Developer Assistant CLI"));
+  console.log();
+  console.log("Welcome to Asiyst CLI.");
+  console.log("Connect your project, manage your avatar, and verify your website integration.");
+  console.log();
+  console.log(section("Project"));
+  console.log(`  ${project && project.packageJson?.name ? String(project.packageJson.name) : process.cwd().split(/[\\/]/).pop() || "current-project"}`);
+  console.log(`  ${connected ? `${symbols.connected} Connected` : `${symbols.disconnected} Not connected`}`);
+  console.log();
+  console.log(section("Environment"));
+  if (project) {
+    console.log(`  ${project.framework} \xB7 ${project.language} \xB7 ${project.packageManager}`);
+    console.log(`  SDK: ${project.sdkVersion ? project.sdkVersion : "not installed"}`);
+  } else {
+    console.log("  Unable to detect project metadata automatically.");
+  }
+  console.log();
+  console.log(muted("\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500"));
+  console.log();
+}
+async function interactiveHome() {
+  const project = detectProject();
+  const initialConnection = await loadConnection(process.cwd());
+  console.clear();
+  renderLogo();
+  renderWelcome(project, Boolean(initialConnection));
   for (; ; ) {
-    const result = await selectOption("What would you like to do?", suggestions, "\u203A ");
-    if (result.type === "exit") break;
-    if (result.type !== "selected") continue;
-    const command = resolveInput(result.input || String(result.value));
-    if (command === "exit" || command === "quit") {
-      const confirmed = await selectOption("Exit Asiyst?", [
-        { label: "Yes", value: true },
-        { label: "No", value: false }
-      ]);
-      if (confirmed.type === "selected") {
-        if (confirmed.value) break;
-      }
-      continue;
-    }
-    if (command === "connect") await initCommand();
-    else if (command === "status") await statusCommand();
-    else if (command === "diagnostics") await doctorCommand();
-    else if (command === "dashboard") await dashboardCommand();
-    else if (command === "avatar") await avatarCommand();
-    else if (command === "update") await updateCommand();
-    else if (command === "logout") logoutCommand();
-    else if (command === "trust") await trustCommand();
-    else if (command === "revoke-trust") revokeTrustCommand();
-    else if (command === "help") interactiveHelp();
-    else if (command === "version") console.log(readCurrentVersion());
-    else console.log(`I don't recognize that command: ${result.input}
-Run 'asiyst help' for available commands.`);
+    const command = await readCommand();
+    if (!command || !await runInteractiveCommand(command)) break;
   }
 }
 
 // src/index.ts
 import { fileURLToPath as fileURLToPath2 } from "url";
+import { realpathSync } from "fs";
 var CLI_VERSION = readCurrentVersion();
 function help() {
   interactiveHelp();
 }
 async function main(argv = process.argv.slice(2)) {
   const command = argv[0] || "";
+  const projectId = parseProjectIdArgument(argv);
   if (command !== "update" && !argv.includes("--version") && !argv.includes("-v") && !argv.includes("--help") && !argv.includes("-h")) {
     await notifyIfUpdateAvailable();
   }
   if (command === "--help" || command === "-h") return help();
   if (command === "--version" || command === "-v") return console.log(CLI_VERSION);
-  if (command === "init" || command === "connect") return initCommand();
+  if (command === "init") return connectCommand(process.cwd(), void 0, projectId);
+  if (command === "connect") return connectCommand(process.cwd(), void 0, projectId);
   if (command === "login") return loginCommand();
   if (command === "logout") return logoutCommand();
+  if (command === "disconnect") return disconnectCommand();
   if (command === "status") return statusCommand();
   if (command === "verify") return verifyCommand();
+  if (command === "health") return healthCommand();
   if (command === "doctor") return doctorCommand();
   if (command === "diagnostics") return doctorCommand();
   if (command === "dashboard") return dashboardCommand();
-  if (command === "avatar") return avatarCommand();
+  if (command === "avatar") return avatarCommand(process.cwd(), argv.slice(1));
   if (command === "trust") return trustCommand();
   if (command === "revoke-trust") return revokeTrustCommand();
   if (command === "update") return updateCommand();
   if (command === "help") return help();
-  if (command === "version") return console.log(CLI_VERSION);
+  if (command === "version") return console.log(`Asiyst CLI v${CLI_VERSION}
+\u2713 Latest version`);
   if (!process.stdin.isTTY) {
-    const project = detectProject();
-    projectChecks(project);
-    console.log("\nRun `npx @asiyst/cli connect` to connect this project, or `npx @asiyst/cli --help` for commands.");
+    help();
     return;
   }
   return interactiveHome();
 }
-if (process.argv[1] && fileURLToPath2(import.meta.url) === process.argv[1]) {
+function isDirectExecution() {
+  if (!process.argv[1]) return false;
+  try {
+    const entryPath = realpathSync(fileURLToPath2(import.meta.url));
+    const execPath = realpathSync(process.argv[1]);
+    return entryPath.toLowerCase() === execPath.toLowerCase();
+  } catch {
+    return true;
+  }
+}
+if (isDirectExecution()) {
   main().catch((error) => {
     console.error(`
 Error: ${error instanceof Error ? error.message : "command failed"}`);
@@ -792,6 +2139,7 @@ Error: ${error instanceof Error ? error.message : "command failed"}`);
 }
 export {
   CLI_VERSION,
+  connectCommand as initCommand,
   main
 };
 //# sourceMappingURL=index.js.map