@clawstore/clawstore 1.0.0

package/src/core/skill-installer.ts

@@ -0,0 +1,221 @@
+import { access, readFile, writeFile, mkdir, cp } from "node:fs/promises";
+import { existsSync, readFileSync } from "node:fs";
+import { join, dirname } from "node:path";
+import { exec } from "node:child_process";
+import { promisify } from "node:util";
+import semver from "semver";
+import { OPENCLAW_HOME, DEFAULT_AGENT, agentSkillRegistryFile } from "../constants.js";
+import type { SkillDependency, SkillRegistry, InstalledSkillRecord } from "../types.js";
+import { resolveWorkspace } from "./workspace.js";
+
+const execAsync = promisify(exec);
+
+async function exists(p: string): Promise<boolean> {
+  try {
+    await access(p);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+// ─── Skill Registry ─────────────────────────────────────────────────
+
+async function loadSkillRegistry(agent: string = DEFAULT_AGENT): Promise<SkillRegistry> {
+  const file = agentSkillRegistryFile(agent);
+  if (!(await exists(file))) {
+    return { skills: {} };
+  }
+  const raw = await readFile(file, "utf-8");
+  return JSON.parse(raw) as SkillRegistry;
+}
+
+async function saveSkillRegistry(reg: SkillRegistry, agent: string = DEFAULT_AGENT): Promise<void> {
+  const file = agentSkillRegistryFile(agent);
+  await mkdir(dirname(file), { recursive: true });
+  await writeFile(file, JSON.stringify(reg, null, 2), "utf-8");
+}
+
+// ─── Version helpers ────────────────────────────────────────────────
+
+function getInstalledSkillVersion(skillDir: string): string | null {
+  try {
+    const pkgPath = join(skillDir, "package.json");
+    if (!existsSync(pkgPath)) return null;
+    const pkg = JSON.parse(readFileSync(pkgPath, "utf-8"));
+    return pkg.version ?? null;
+  } catch {
+    return null;
+  }
+}
+
+function versionSatisfies(installed: string | null, required: string): boolean {
+  if (!installed) return false;
+  if (required === "latest" || required === "*") return true;
+  return semver.satisfies(installed, required);
+}
+
+// ─── Core: check + install skills ───────────────────────────────────
+
+export interface SkillCheckResult {
+  skillId: string;
+  required: boolean;
+  requiredVersion: string;
+  installedVersion: string | null;
+  action: "skip" | "install" | "upgrade";
+}
+
+export function checkSkillDependencies(skills: SkillDependency[]): SkillCheckResult[] {
+  const skillsDir = join(OPENCLAW_HOME, "skills");
+  const results: SkillCheckResult[] = [];
+
+  for (const skill of skills) {
+    const dir = join(skillsDir, skill.id);
+    const installedVersion = getInstalledSkillVersion(dir);
+    const dirExists = existsSync(dir);
+
+    let action: "skip" | "install" | "upgrade";
+    if (!dirExists) {
+      action = "install";
+    } else if (!versionSatisfies(installedVersion, skill.version)) {
+      action = "upgrade";
+    } else {
+      action = "skip";
+    }
+
+    results.push({
+      skillId: skill.id,
+      required: skill.required,
+      requiredVersion: skill.version,
+      installedVersion,
+      action,
+    });
+  }
+
+  return results;
+}
+
+/**
+ * Try to install a skill from the bundled package skills/ directory.
+ */
+async function installSkillFromBundle(
+  skillId: string,
+  packagePath: string,
+  agent: string = DEFAULT_AGENT,
+): Promise<{ ok: boolean; message: string }> {
+  const bundledFile = join(packagePath, "skills", `${skillId}.md`);
+  const bundledDir = join(packagePath, "skills", skillId);
+
+  if (await exists(bundledFile)) {
+    const workspace = await resolveWorkspace(agent);
+    const destDir = join(workspace, "skills");
+    await mkdir(destDir, { recursive: true });
+    await cp(bundledFile, join(destDir, `${skillId}.md`), { force: true });
+    return { ok: true, message: `installed from bundle (${skillId}.md)` };
+  }
+
+  if (await exists(bundledDir)) {
+    const workspace = await resolveWorkspace(agent);
+    const destDir = join(workspace, "skills", skillId);
+    await cp(bundledDir, destDir, { recursive: true, force: true });
+    return { ok: true, message: `installed from bundle (${skillId}/)` };
+  }
+
+  return { ok: false, message: "not found in bundle" };
+}
+
+/**
+ * Install or upgrade a single skill.
+ *
+ * Strategy:
+ *   1. Try bundled skills/ in the package directory first
+ *   2. Fall back to `openclaw plugins install <skill-id>` (npm registry)
+ */
+export async function installSkill(
+  skillId: string,
+  version: string,
+  packagePath?: string,
+  agent: string = DEFAULT_AGENT,
+): Promise<{ ok: boolean; message: string }> {
+  if (packagePath) {
+    const bundled = await installSkillFromBundle(skillId, packagePath, agent);
+    if (bundled.ok) {
+      const reg = await loadSkillRegistry(agent);
+      reg.skills[skillId] = {
+        skill_id: skillId,
+        version,
+        installed_at: new Date().toISOString(),
+        installed_by: "clawstore",
+        source: `bundle:${packagePath}`,
+      };
+      await saveSkillRegistry(reg, agent);
+      return bundled;
+    }
+  }
+
+  const spec = version && version !== "latest" ? `${skillId}@${version}` : skillId;
+  try {
+    const cmd = `openclaw plugins install ${JSON.stringify(spec)}`;
+    const { stdout, stderr } = await execAsync(cmd, { timeout: 60_000 });
+    const output = stdout || stderr;
+
+    const reg = await loadSkillRegistry(agent);
+    reg.skills[skillId] = {
+      skill_id: skillId,
+      version,
+      installed_at: new Date().toISOString(),
+      installed_by: "clawstore",
+      source: `npm:${spec}`,
+    };
+    await saveSkillRegistry(reg, agent);
+
+    return { ok: true, message: output.trim() || `installed ${spec}` };
+  } catch (err) {
+    return {
+      ok: false,
+      message: `failed to install ${spec}: ${(err as Error).message}`,
+    };
+  }
+}
+
+/**
+ * Install all required skills for an agent.
+ */
+export async function installRequiredSkills(
+  skills: SkillDependency[],
+  log?: (msg: string) => void,
+  packagePath?: string,
+  agent: string = DEFAULT_AGENT,
+): Promise<{ allOk: boolean; results: Array<SkillCheckResult & { installResult?: { ok: boolean; message: string } }> }> {
+  const checks = checkSkillDependencies(skills);
+  let allOk = true;
+
+  const results: Array<SkillCheckResult & { installResult?: { ok: boolean; message: string } }> = [];
+
+  for (const check of checks) {
+    if (check.action === "skip") {
+      log?.(`    - ${check.skillId} ${check.requiredVersion} ... already installed`);
+      results.push(check);
+      continue;
+    }
+
+    if (!check.required) {
+      log?.(`    - ${check.skillId} ${check.requiredVersion} ... SKIPPED (optional)`);
+      log?.(`      Run: openclaw plugins install ${check.skillId}`);
+      results.push(check);
+      continue;
+    }
+
+    log?.(`    - ${check.skillId} ${check.requiredVersion} ... installing`);
+    const installResult = await installSkill(check.skillId, check.requiredVersion, packagePath, agent);
+    if (installResult.ok) {
+      log?.(`      ${installResult.message}`);
+    } else {
+      log?.(`      FAILED: ${installResult.message}`);
+      allOk = false;
+    }
+    results.push({ ...check, installResult });
+  }
+
+  return { allOk, results };
+}

package/src/core/store-client.ts

@@ -0,0 +1,140 @@
+import type {
+  StoreSearchResult,
+  StoreAgentDetail,
+  StoreAgentSummary,
+  ClawstoreConfig,
+} from "../types.js";
+import { DEFAULT_API_BASE_URL } from "../constants.js";
+
+/**
+ * HTTP client for the Clawstore Web API.
+ *
+ * All methods are async and use the native `fetch` API.
+ * When the Clawstore backend is not yet deployed, methods throw
+ * descriptive errors so the CLI can gracefully inform the user.
+ */
+export class StoreClient {
+  private baseUrl: string;
+  private authToken: string | null = null;
+
+  constructor(config?: Partial<ClawstoreConfig>) {
+    this.baseUrl = (config?.apiBaseUrl ?? DEFAULT_API_BASE_URL).replace(/\/+$/, "");
+  }
+
+  setAuthToken(token: string): void {
+    this.authToken = token;
+  }
+
+  private headers(): Record<string, string> {
+    const h: Record<string, string> = {
+      "Content-Type": "application/json",
+      "User-Agent": "clawstore-plugin/1.0.0",
+    };
+    if (this.authToken) {
+      h["Authorization"] = `Bearer ${this.authToken}`;
+    }
+    return h;
+  }
+
+  private async request<T>(path: string, init?: RequestInit): Promise<T> {
+    const url = `${this.baseUrl}${path}`;
+    const res = await fetch(url, {
+      ...init,
+      headers: { ...this.headers(), ...(init?.headers as Record<string, string> ?? {}) },
+      signal: AbortSignal.timeout(15_000),
+    });
+    if (!res.ok) {
+      const body = await res.text().catch(() => "");
+      throw new Error(`API ${res.status}: ${res.statusText}${body ? ` — ${body}` : ""}`);
+    }
+    return res.json() as Promise<T>;
+  }
+
+  // ─── Search ─────────────────────────────────────────────────────
+
+  async search(query: string, opts?: {
+    category?: string;
+    sort?: string;
+    limit?: number;
+  }): Promise<StoreSearchResult> {
+    const params = new URLSearchParams();
+    if (query) params.set("q", query);
+    if (opts?.category) params.set("category", opts.category);
+    if (opts?.sort) params.set("sort", opts.sort);
+    if (opts?.limit) params.set("limit", String(opts.limit));
+    return this.request<StoreSearchResult>(`/agents?${params}`);
+  }
+
+  // ─── Show detail ────────────────────────────────────────────────
+
+  async getAgentDetail(agentId: string): Promise<StoreAgentDetail> {
+    return this.request<StoreAgentDetail>(`/agents/${agentId}`);
+  }
+
+  // ─── Download URL ───────────────────────────────────────────────
+
+  async getDownloadUrl(agentId: string): Promise<string> {
+    const res = await this.request<{ url: string }>(`/agents/${agentId}/download`);
+    return res.url;
+  }
+
+  // ─── Publish draft ──────────────────────────────────────────────
+
+  async publishDraft(zipBuffer: Buffer, metadata: {
+    name: string;
+    description: string;
+    category: string;
+    price: number;
+    currency: string;
+  }): Promise<{ draftId: string; editUrl: string }> {
+    const formData = new FormData();
+    formData.append("file", new Blob([zipBuffer]), "agent.zip");
+    formData.append("metadata", JSON.stringify(metadata));
+
+    const url = `${this.baseUrl}/agents/drafts`;
+    const res = await fetch(url, {
+      method: "POST",
+      headers: {
+        ...(this.authToken ? { Authorization: `Bearer ${this.authToken}` } : {}),
+        "User-Agent": "clawstore-plugin/1.0.0",
+      },
+      body: formData,
+      signal: AbortSignal.timeout(60_000),
+    });
+
+    if (!res.ok) {
+      throw new Error(`Publish failed: HTTP ${res.status}`);
+    }
+
+    return res.json() as Promise<{ draftId: string; editUrl: string }>;
+  }
+
+  // ─── Auth ───────────────────────────────────────────────────────
+
+  async login(email: string, password: string): Promise<{ token: string; user: { id: string; name: string } }> {
+    return this.request<{ token: string; user: { id: string; name: string } }>("/auth/login", {
+      method: "POST",
+      body: JSON.stringify({ email, password }),
+    });
+  }
+
+  async whoami(): Promise<{ id: string; name: string; email: string } | null> {
+    if (!this.authToken) return null;
+    try {
+      return await this.request<{ id: string; name: string; email: string }>("/auth/me");
+    } catch {
+      return null;
+    }
+  }
+
+  // ─── Health ─────────────────────────────────────────────────────
+
+  async healthCheck(): Promise<boolean> {
+    try {
+      await this.request<{ status: string }>("/health");
+      return true;
+    } catch {
+      return false;
+    }
+  }
+}

package/src/core/workspace.ts

@@ -0,0 +1,269 @@
+import { readFile, access, readdir, stat } from "node:fs/promises";
+import { join } from "node:path";
+import { homedir } from "node:os";
+import {
+  OPENCLAW_HOME,
+  CLAWSTORE_DIR,
+  DEFAULT_AGENT,
+  REQUIRED_FILES,
+  OPTIONAL_FILES,
+  agentRegistryFile,
+  agentSkillRegistryFile,
+  agentBackupDir,
+} from "../constants.js";
+import type { DiagnosticCheck, DiagnosticReport } from "../types.js";
+
+/**
+ * Resolve the workspace directory for a given OpenClaw agent.
+ *
+ * @param agent  OpenClaw agent name (default "main")
+ *
+ * Resolution priority:
+ *   1. Per-agent workspace in openclaw.json (`agents.<agent>.workspace` or
+ *      `agents.entries.<agent>.workspace`)
+ *   2. For "main": `agents.defaults.workspace` or `agent.workspace`
+ *   3. OPENCLAW_PROFILE env -> `~/.openclaw/workspace-{profile}` (main only)
+ *   4. Default: `~/.openclaw/workspace` for main,
+ *              `~/.openclaw/workspace-{agent}` for others
+ */
+export async function resolveWorkspace(agent?: string): Promise<string> {
+  const target = agent ?? DEFAULT_AGENT;
+  const configFile = join(OPENCLAW_HOME, "openclaw.json");
+
+  try {
+    const raw = await readFile(configFile, "utf-8");
+    const config = JSON.parse(raw);
+
+    let workspace: string | undefined;
+
+    if (target !== DEFAULT_AGENT) {
+      workspace =
+        config?.agents?.[target]?.workspace ??
+        config?.agents?.entries?.[target]?.workspace;
+    } else {
+      workspace =
+        config?.agents?.defaults?.workspace ??
+        config?.agent?.workspace;
+    }
+
+    if (workspace && typeof workspace === "string") {
+      return expandHome(workspace);
+    }
+  } catch {
+    // config not found or invalid — fall through
+  }
+
+  if (target === DEFAULT_AGENT) {
+    const profile = process.env.OPENCLAW_PROFILE ?? "default";
+    if (profile !== "default") {
+      return join(OPENCLAW_HOME, `workspace-${profile}`);
+    }
+    return join(OPENCLAW_HOME, "workspace");
+  }
+
+  return join(OPENCLAW_HOME, `workspace-${target}`);
+}
+
+function expandHome(p: string): string {
+  if (p.startsWith("~/") || p.startsWith("~\\")) {
+    return join(homedir(), p.slice(2));
+  }
+  if (p === "~") return homedir();
+  return p;
+}
+
+/**
+ * List all OpenClaw agents that have at least one Persona installed via
+ * Clawstore.  Returns agent names (e.g. ["main", "sales"]).
+ */
+export async function listClawstoreAgents(): Promise<string[]> {
+  const agents: string[] = [];
+
+  // "main" agent uses the root-level registry file
+  if (await exists(agentRegistryFile(DEFAULT_AGENT))) {
+    agents.push(DEFAULT_AGENT);
+  }
+
+  // Non-main agents live under clawstore/agents/<name>/
+  const agentsDir = join(CLAWSTORE_DIR, "agents");
+  if (await exists(agentsDir)) {
+    const entries = await readdir(agentsDir, { withFileTypes: true });
+    for (const e of entries) {
+      if (e.isDirectory() && e.name !== DEFAULT_AGENT) {
+        if (await exists(agentRegistryFile(e.name))) {
+          agents.push(e.name);
+        }
+      }
+    }
+  }
+
+  return agents;
+}
+
+async function exists(p: string): Promise<boolean> {
+  try {
+    await access(p);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+async function dirItemCount(p: string): Promise<number> {
+  try {
+    const entries = await readdir(p);
+    return entries.length;
+  } catch {
+    return -1;
+  }
+}
+
+/**
+ * Run a full diagnostic for a specific OpenClaw agent.
+ */
+export async function diagnose(apiBaseUrl?: string, agent?: string): Promise<DiagnosticReport> {
+  const target = agent ?? DEFAULT_AGENT;
+  const checks: DiagnosticCheck[] = [];
+  let allOk = true;
+  const workspace = await resolveWorkspace(target);
+  const registryFile = agentRegistryFile(target);
+  const backupDir = agentBackupDir(target);
+
+  if (target !== DEFAULT_AGENT) {
+    checks.push({
+      label: "Target agent",
+      status: "ok",
+      detail: target,
+    });
+  }
+
+  // 1. OpenClaw home
+  const homeOk = await exists(OPENCLAW_HOME);
+  checks.push({
+    label: "OpenClaw home",
+    path: OPENCLAW_HOME,
+    status: homeOk ? "ok" : "fail",
+    detail: homeOk ? undefined : "NOT FOUND",
+  });
+  if (!homeOk) allOk = false;
+
+  // 2. Workspace
+  const wsOk = await exists(workspace);
+  checks.push({
+    label: "Workspace",
+    path: workspace,
+    status: wsOk ? "ok" : "fail",
+    detail: wsOk ? undefined : "NOT FOUND",
+  });
+  if (!wsOk) allOk = false;
+
+  // 3. Workspace files
+  for (const f of [...REQUIRED_FILES, ...OPTIONAL_FILES]) {
+    const fp = join(workspace, f);
+    const found = await exists(fp);
+    checks.push({
+      label: `Workspace file: ${f}`,
+      path: fp,
+      status: found ? "ok" : "warn",
+      detail: found ? "found" : "missing",
+    });
+  }
+
+  // 4. Registry
+  const regOk = await exists(registryFile);
+  if (regOk) {
+    try {
+      const raw = await readFile(registryFile, "utf-8");
+      const reg = JSON.parse(raw);
+      const count = Object.keys(reg.agents ?? {}).length;
+      checks.push({
+        label: "Agent registry",
+        path: registryFile,
+        status: "ok",
+        detail: `${count} agent(s) registered`,
+      });
+    } catch {
+      checks.push({
+        label: "Agent registry",
+        path: registryFile,
+        status: "warn",
+        detail: "exists but cannot be parsed",
+      });
+    }
+  } else {
+    checks.push({
+      label: "Agent registry",
+      path: registryFile,
+      status: "ok",
+      detail: "not created yet (OK for first run)",
+    });
+  }
+
+  // 5. Skills directory
+  const skillsDir = join(workspace, "skills");
+  const skillCount = await dirItemCount(skillsDir);
+  checks.push({
+    label: "Skills directory",
+    path: skillsDir,
+    status: skillCount >= 0 ? "ok" : "warn",
+    detail: skillCount >= 0 ? `${skillCount} skill(s)` : "NOT FOUND",
+  });
+
+  // 6. Backup directory
+  const backupCount = await dirItemCount(backupDir);
+  checks.push({
+    label: "Backup directory",
+    path: backupDir,
+    status: "ok",
+    detail: backupCount >= 0 ? `${backupCount} backup(s)` : "will be created on first install",
+  });
+
+  // 7. Cache directory
+  const cacheCount = await dirItemCount(join(CLAWSTORE_DIR, "cache"));
+  checks.push({
+    label: "Cache directory",
+    path: join(CLAWSTORE_DIR, "cache"),
+    status: "ok",
+    detail: cacheCount >= 0 ? `${cacheCount} item(s)` : "will be created on first install",
+  });
+
+  // 8. API connectivity (optional)
+  if (apiBaseUrl) {
+    try {
+      const res = await fetch(`${apiBaseUrl}/health`, { signal: AbortSignal.timeout(5000) });
+      checks.push({
+        label: "Clawstore API",
+        status: res.ok ? "ok" : "warn",
+        detail: res.ok ? "reachable" : `HTTP ${res.status}`,
+      });
+    } catch (err) {
+      checks.push({
+        label: "Clawstore API",
+        status: "warn",
+        detail: `unreachable (${(err as Error).message})`,
+      });
+    }
+  }
+
+  return { checks, allOk };
+}
+
+/**
+ * Format a diagnostic report for CLI output.
+ */
+export function formatDiagnosticReport(report: DiagnosticReport): string {
+  const lines: string[] = ["\n  Clawstore Doctor\n"];
+  for (const c of report.checks) {
+    const icon = c.status === "ok" ? "OK" : c.status === "warn" ? "WARN" : "FAIL";
+    const pathPart = c.path ? ` ${c.path}` : "";
+    const detailPart = c.detail ? ` (${c.detail})` : "";
+    lines.push(`  ${c.label}:${pathPart} ... ${icon}${detailPart}`);
+  }
+  lines.push("");
+  lines.push(
+    report.allOk
+      ? "  All checks passed.\n"
+      : "  Some issues found. Run `openclaw setup` to initialize missing directories.\n"
+  );
+  return lines.join("\n");
+}