@corvio/cli 0.1.0-beta.2

package/README.md

@@ -0,0 +1,12 @@
+# Corvio Workspace CLI
+
+Official CLI for a user's Corvio Workspace. It supports an existing `CORVIO_API_KEY` and a browser device-link login.
+
+```bash
+npm install --global @corvio/cli
+export CORVIO_API_KEY='cvk_...'
+corvio auth status
+corvio ask --prompt 'Summarize recurring launch risks' --json
+```
+
+When no environment key is configured, run `corvio auth login`. The environment key always takes precedence. See [the Corvio CLI guide](https://corvio.ai/developers/cli) for the supported command and receipt contract.

package/dist/cli.js

@@ -0,0 +1,323 @@
+#!/usr/bin/env node
+
+import {
+  ApiClient,
+  CliError,
+  EXIT,
+  clearWorkspaceCredential,
+  idempotencyKey,
+  listOption,
+  normalizeApiBase,
+  numberOption,
+  openBrowser,
+  option,
+  readTextFile,
+  readWorkspaceCredential,
+  requireConfirmation,
+  runMain,
+  sleep,
+  storeWorkspaceCredential,
+  writeResult,
+  writeTextFile,
+} from "./core.js";
+
+const VERSION = "0.1.0-beta.2";
+const DEFAULT_API_BASE = "https://api.corvio.ai/v1";
+const DEFAULT_APP_BASE = "https://corvio.ai";
+const USER_AGENT = `corvio-cli/${VERSION}`;
+
+const HELP = `Corvio Workspace CLI ${VERSION}
+
+Usage:
+  corvio auth login|status|logout
+  corvio capabilities
+  corvio ask --prompt <text> [--conversation-id <id>] [--allow-actions]
+  corvio questions list|get [id]
+  corvio conversations list|get [id]
+  corvio search <query>
+  corvio docs list|get|create|update|archive|share|open [id]
+
+Global options:
+  --api-base <url>  --json  --no-input  --yes  --help  --version
+
+Authentication:
+  CORVIO_API_KEY=cvk_... takes precedence over the stored device-link login.
+  Run 'corvio auth login' when no environment key is configured.
+`;
+
+function baseUrl(options) {
+  return normalizeApiBase(options["api-base"] || process.env.CORVIO_API_BASE, DEFAULT_API_BASE);
+}
+
+async function client(options, { auth = true } = {}) {
+  const credential = auth ? await readWorkspaceCredential() : null;
+  if (auth && !credential) {
+    throw new CliError("No Corvio credential found. Set CORVIO_API_KEY or run `corvio auth login`.", {
+      code: "auth_required",
+      exitCode: EXIT.AUTH,
+    });
+  }
+  return {
+    api: new ApiClient({ baseUrl: baseUrl(options), credential: credential?.key, userAgent: USER_AGENT }),
+    credential,
+  };
+}
+
+async function authLogin(options) {
+  const current = await readWorkspaceCredential();
+  if (current?.source === "environment" && !options.force) {
+    const { api } = await client(options);
+    const identity = await api.request("/me");
+    writeResult({ authenticated: true, source: "environment", identity }, { json: options.json });
+    return;
+  }
+  const api = new ApiClient({ baseUrl: baseUrl(options), userAgent: USER_AGENT });
+  const authorization = await api.request("/auth/device-authorizations", {
+    method: "POST",
+    auth: false,
+    body: {
+      client_name: "Corvio Workspace CLI",
+      cli_version: VERSION,
+      scopes: [
+        "questions:read",
+        "questions:write",
+        "search:read",
+        "documents:read",
+        "documents:write",
+        "documents:share",
+      ],
+    },
+  });
+  const diagnostic = `Open ${authorization.verification_uri_complete}\nCode: ${authorization.user_code}\n`;
+  process.stderr.write(diagnostic);
+  if (!options["no-input"]) await openBrowser(authorization.verification_uri_complete);
+
+  const expiresAt = Date.now() + Number(authorization.expires_in || 600) * 1000;
+  let intervalSeconds = Math.max(5, Number(authorization.interval || 5));
+  let token;
+  while (Date.now() < expiresAt) {
+    await sleep(intervalSeconds * 1000);
+    try {
+      token = await api.request("/auth/device-token", {
+        method: "POST",
+        auth: false,
+        body: { device_code: authorization.device_code },
+      });
+      break;
+    } catch (error) {
+      if (!(error instanceof CliError)) throw error;
+      if (error.code === "authorization_pending") continue;
+      if (error.code === "slow_down") {
+        intervalSeconds = Math.min(30, intervalSeconds + 5);
+        continue;
+      }
+      throw error;
+    }
+  }
+  if (!token?.secret) {
+    throw new CliError("Device authorization expired; run `corvio auth login` again.", {
+      code: "expired_token",
+      exitCode: EXIT.AUTH,
+    });
+  }
+  const stored = await storeWorkspaceCredential(token);
+  const authenticatedApi = new ApiClient({ baseUrl: baseUrl(options), credential: token.secret, userAgent: USER_AGENT });
+  const identity = await authenticatedApi.request("/me");
+  writeResult({
+    authenticated: true,
+    source: "device_link",
+    profile: stored.profile,
+    workspace: identity.workspace,
+    scopes: identity.api_key?.scopes || [],
+  }, { json: options.json });
+}
+
+async function authStatus(options) {
+  const credential = await readWorkspaceCredential();
+  if (!credential) {
+    writeResult({ authenticated: false, sources: ["CORVIO_API_KEY", "device_link"] }, { json: options.json });
+    return;
+  }
+  const api = new ApiClient({ baseUrl: baseUrl(options), credential: credential.key, userAgent: USER_AGENT });
+  const identity = await api.request("/me");
+  writeResult({
+    authenticated: true,
+    source: credential.source,
+    profile: credential.profile,
+    user: identity.user,
+    workspace: identity.workspace,
+    api_key: identity.api_key,
+  }, { json: options.json });
+}
+
+async function authLogout(options) {
+  const credential = await readWorkspaceCredential();
+  if (!credential) {
+    writeResult({ authenticated: false, changed: false }, { json: options.json });
+    return;
+  }
+  if (credential.source === "environment") {
+    throw new CliError("CORVIO_API_KEY is managed by the parent environment and cannot be removed by the CLI.", {
+      code: "environment_credential_managed_externally",
+      exitCode: EXIT.AUTH,
+    });
+  }
+  const api = new ApiClient({ baseUrl: baseUrl(options), credential: credential.key, userAgent: USER_AGENT });
+  await api.request("/auth/credentials/current:revoke", { method: "POST" });
+  await clearWorkspaceCredential();
+  writeResult({ authenticated: false, revoked: true, profile: credential.profile }, { json: options.json });
+}
+
+async function capabilities(options) {
+  const { api, credential } = await client(options);
+  const [index, identity] = await Promise.all([api.request("", { auth: false }), api.request("/me")]);
+  writeResult({
+    cli_version: VERSION,
+    auth_source: credential.source,
+    api: index,
+    principal: identity,
+    unavailable: {
+      files: "Public Workspace Asset upload/organization is not advertised by /v1 yet.",
+      sync: "Public Local Sync adapters are not advertised by /v1 yet.",
+    },
+  }, { json: options.json });
+}
+
+async function ask(options, positionals) {
+  const prompt = String(options.prompt || positionals.join(" ")).trim();
+  if (!prompt) throw new CliError("Provide --prompt <text> or a positional prompt.");
+  const { api } = await client(options);
+  const result = await api.request("/questions", {
+    method: "POST",
+    headers: { "idempotency-key": idempotencyKey(options) },
+    body: {
+      prompt,
+      conversation_id: options["conversation-id"] || null,
+      mode: options["allow-actions"] ? "allow_actions" : "answer_only",
+      sources: listOption(options, "sources", ["workspace", "web", "memory"]),
+    },
+  });
+  writeResult(result, { json: options.json });
+}
+
+function pageQuery(options) {
+  return {
+    limit: numberOption(options, "limit", 20),
+    cursor: options.cursor,
+    conversation_id: options["conversation-id"],
+  };
+}
+
+async function questions(options, action, id) {
+  const { api } = await client(options);
+  const result = action === "list"
+    ? await api.request("/questions", { query: pageQuery(options) })
+    : await api.request(`/questions/${id || option(options, "id", { required: true })}`);
+  writeResult(result, { json: options.json });
+}
+
+async function conversations(options, action, id) {
+  const { api } = await client(options);
+  const result = action === "list"
+    ? await api.request("/conversations", { query: pageQuery(options) })
+    : await api.request(`/conversations/${id || option(options, "id", { required: true })}`);
+  writeResult(result, { json: options.json });
+}
+
+async function search(options, positionals) {
+  const query = String(options.query || positionals.join(" ")).trim();
+  if (!query) throw new CliError("Provide a search query.");
+  const { api } = await client(options);
+  const result = await api.request("/search", {
+    method: "POST",
+    body: {
+      query,
+      limit: numberOption(options, "limit", 10),
+      page_id: options["page-id"] || null,
+      node_id: options["node-id"] || null,
+    },
+  });
+  writeResult(result, { json: options.json });
+}
+
+async function docs(options, action, id) {
+  const { api } = await client(options);
+  const documentId = id || options.id;
+  let result;
+  if (action === "list") {
+    result = await api.request("/documents", { query: pageQuery(options) });
+  } else if (action === "get") {
+    result = await api.request(`/documents/${documentId || option(options, "id", { required: true })}`);
+    if (options.output) {
+      await writeTextFile(options.output, String(result.markdown || ""));
+      result = { ...result, output: options.output };
+    }
+  } else if (action === "create") {
+    const markdown = options.file ? await readTextFile(options.file) : String(options.markdown || "");
+    result = await api.request("/documents", {
+      method: "POST",
+      headers: { "idempotency-key": idempotencyKey(options) },
+      body: {
+        title: option(options, "title", { required: true }),
+        markdown,
+        parent_node_id: options["parent-node-id"] || null,
+        doc_type: "page",
+      },
+    });
+  } else if (action === "update") {
+    const markdown = options.file ? await readTextFile(options.file) : options.markdown;
+    result = await api.request(`/documents/${documentId || option(options, "id", { required: true })}`, {
+      method: "PUT",
+      body: {
+        ...(options.title ? { title: options.title } : {}),
+        ...(markdown !== undefined ? { markdown } : {}),
+        ...(options["expected-revision"] !== undefined
+          ? { expected_content_revision: Number.parseInt(options["expected-revision"], 10) }
+          : {}),
+      },
+    });
+  } else if (action === "archive") {
+    requireConfirmation(options, "Archiving a document");
+    result = await api.request(`/documents/${documentId || option(options, "id", { required: true })}`, { method: "DELETE" });
+  } else if (action === "share") {
+    requireConfirmation(options, "Creating a document share link");
+    result = await api.request(`/documents/${documentId || option(options, "id", { required: true })}/shares`, {
+      method: "POST",
+      body: { public_display_name: options["display-name"] || null },
+    });
+  } else if (action === "open") {
+    const target = `${String(process.env.CORVIO_APP_BASE || DEFAULT_APP_BASE).replace(/\/+$/, "")}/app/d/${documentId || option(options, "id", { required: true })}`;
+    const opened = options["no-input"] ? false : await openBrowser(target);
+    result = { document_id: documentId, url: target, opened };
+  } else {
+    throw new CliError("docs action must be list, get, create, update, archive, share, or open.");
+  }
+  writeResult(result, { json: options.json });
+}
+
+async function main({ options, positionals }) {
+  const [command, action, id, ...rest] = positionals;
+  if (options.version || command === "version") return writeResult(VERSION, { json: options.json });
+  if (options.help || !command || command === "help") return writeResult(HELP.trimEnd(), { json: false });
+  if (command === "auth") {
+    if (action === "login") return authLogin(options);
+    if (action === "status") return authStatus(options);
+    if (action === "logout") return authLogout(options);
+    throw new CliError("auth action must be login, status, or logout.");
+  }
+  if (command === "capabilities") return capabilities(options);
+  if (command === "ask") return ask(options, [action, id, ...rest].filter(Boolean));
+  if (command === "questions") return questions(options, action || "list", id);
+  if (command === "conversations") return conversations(options, action || "list", id);
+  if (command === "search") return search(options, [action, id, ...rest].filter(Boolean));
+  if (command === "docs") return docs(options, action || "list", id);
+  if (command === "files" || command === "sync") {
+    throw new CliError(`${command} is not available until the public /v1 capability is released.`, {
+      code: `${command}_capability_unavailable`,
+      exitCode: EXIT.UNAVAILABLE,
+    });
+  }
+  throw new CliError(`Unknown command: ${command}`);
+}
+
+await runMain(main);

package/dist/core.js

@@ -0,0 +1,324 @@
+import { spawn } from "node:child_process";
+import { randomUUID } from "node:crypto";
+import { chmod, mkdir, readFile, rename, rm, writeFile } from "node:fs/promises";
+import { homedir, platform } from "node:os";
+import { dirname, join, resolve } from "node:path";
+
+export const EXIT = Object.freeze({
+  OK: 0,
+  USAGE: 2,
+  AUTH: 3,
+  UNAVAILABLE: 4,
+  CONFLICT: 5,
+  RATE_LIMIT: 6,
+  REMOTE: 7,
+});
+
+export class CliError extends Error {
+  constructor(message, { code = "cli_error", exitCode = EXIT.USAGE, status = null, details = null } = {}) {
+    super(message);
+    this.name = "CliError";
+    this.code = code;
+    this.exitCode = exitCode;
+    this.status = status;
+    this.details = details;
+  }
+}
+
+function exitCodeForStatus(status) {
+  if (status === 401 || status === 403) return EXIT.AUTH;
+  if (status === 409) return EXIT.CONFLICT;
+  if (status === 429) return EXIT.RATE_LIMIT;
+  return EXIT.REMOTE;
+}
+
+export function parseArgv(argv) {
+  const options = Object.create(null);
+  const positionals = [];
+  const booleanOptions = new Set([
+    "json",
+    "no-input",
+    "yes",
+    "allow-actions",
+    "private-link",
+    "force",
+    "help",
+    "version",
+  ]);
+  for (let index = 0; index < argv.length; index += 1) {
+    const value = argv[index];
+    if (!value.startsWith("--")) {
+      positionals.push(value);
+      continue;
+    }
+    const separator = value.indexOf("=");
+    const name = value.slice(2, separator === -1 ? undefined : separator);
+    if (booleanOptions.has(name)) {
+      options[name] = separator === -1 ? true : value.slice(separator + 1) !== "false";
+      continue;
+    }
+    if (separator !== -1) {
+      options[name] = value.slice(separator + 1);
+      continue;
+    }
+    const next = argv[index + 1];
+    if (next === undefined || next.startsWith("--")) {
+      throw new CliError(`Option --${name} requires a value.`, { code: "missing_option_value" });
+    }
+    options[name] = next;
+    index += 1;
+  }
+  return { options, positionals };
+}
+
+export function option(options, name, { required = false, fallback = undefined } = {}) {
+  const value = options[name] ?? fallback;
+  if (required && (value === undefined || String(value).trim() === "")) {
+    throw new CliError(`Missing required option --${name}.`, { code: "missing_required_option" });
+  }
+  return value;
+}
+
+export function listOption(options, name, fallback = []) {
+  const value = options[name];
+  if (value === undefined) return fallback;
+  return String(value).split(",").map((item) => item.trim()).filter(Boolean);
+}
+
+export function numberOption(options, name, fallback) {
+  const value = options[name];
+  if (value === undefined) return fallback;
+  const parsed = Number.parseInt(String(value), 10);
+  if (!Number.isFinite(parsed) || parsed < 1) {
+    throw new CliError(`Option --${name} must be a positive integer.`, { code: "invalid_number_option" });
+  }
+  return parsed;
+}
+
+export function normalizeApiBase(value, fallback) {
+  const raw = String(value || fallback).trim().replace(/\/+$/, "");
+  if (!/^https:\/\//i.test(raw) && !/^http:\/\/(127\.0\.0\.1|localhost)(:\d+)?/i.test(raw)) {
+    throw new CliError("Corvio API base must use HTTPS (localhost is allowed for development).", {
+      code: "insecure_api_base",
+    });
+  }
+  return raw.endsWith("/v1") ? raw : `${raw}/v1`;
+}
+
+export class ApiClient {
+  constructor({ baseUrl, credential = null, userAgent, fetchImpl = globalThis.fetch }) {
+    this.baseUrl = baseUrl.replace(/\/+$/, "");
+    this.credential = credential;
+    this.userAgent = userAgent;
+    this.fetchImpl = fetchImpl;
+  }
+
+  async request(path, { method = "GET", body, query, headers = {}, auth = true } = {}) {
+    const url = new URL(`${this.baseUrl}${path.startsWith("/") ? path : `/${path}`}`);
+    for (const [key, value] of Object.entries(query || {})) {
+      if (value !== undefined && value !== null && value !== "") url.searchParams.set(key, String(value));
+    }
+    const requestHeaders = {
+      accept: "application/json",
+      "user-agent": this.userAgent,
+      ...headers,
+    };
+    if (body !== undefined) requestHeaders["content-type"] = "application/json";
+    if (auth) {
+      if (!this.credential) {
+        throw new CliError("Corvio authentication is required.", { code: "auth_required", exitCode: EXIT.AUTH });
+      }
+      requestHeaders.authorization = `Bearer ${this.credential}`;
+    }
+    let response;
+    try {
+      response = await this.fetchImpl(url, {
+        method,
+        headers: requestHeaders,
+        body: body === undefined ? undefined : JSON.stringify(body),
+      });
+    } catch (cause) {
+      throw new CliError(`Unable to reach Corvio: ${cause instanceof Error ? cause.message : String(cause)}`, {
+        code: "network_error",
+        exitCode: EXIT.REMOTE,
+      });
+    }
+    const text = await response.text();
+    let payload = null;
+    if (text) {
+      try {
+        payload = JSON.parse(text);
+      } catch {
+        payload = { message: text.slice(0, 500) };
+      }
+    }
+    if (!response.ok) {
+      const envelope = payload?.error || payload?.detail || payload || {};
+      throw new CliError(String(envelope.message || envelope.code || `Corvio request failed (${response.status}).`), {
+        code: String(envelope.code || `http_${response.status}`),
+        status: response.status,
+        exitCode: exitCodeForStatus(response.status),
+        details: envelope.details || null,
+      });
+    }
+    return payload;
+  }
+}
+
+function configRoot(env = process.env) {
+  if (env.CORVIO_CONFIG_DIR) return resolve(env.CORVIO_CONFIG_DIR);
+  if (env.XDG_CONFIG_HOME) return join(resolve(env.XDG_CONFIG_HOME), "corvio");
+  return join(homedir(), ".config", "corvio");
+}
+
+export function workspaceCredentialPath(env = process.env) {
+  return join(configRoot(env), "credentials.json");
+}
+
+export async function readWorkspaceCredential(env = process.env) {
+  const environmentKey = String(env.CORVIO_API_KEY || "").trim();
+  if (environmentKey) {
+    if (!environmentKey.startsWith("cvk_")) {
+      throw new CliError("CORVIO_API_KEY must be a Workspace cvk_ key.", {
+        code: "invalid_workspace_key",
+        exitCode: EXIT.AUTH,
+      });
+    }
+    return { key: environmentKey, source: "environment", profile: null, metadata: null };
+  }
+  const path = workspaceCredentialPath(env);
+  let parsed;
+  try {
+    parsed = JSON.parse(await readFile(path, "utf8"));
+  } catch (cause) {
+    if (cause?.code === "ENOENT") return null;
+    throw new CliError("Stored Corvio credentials are unreadable.", { code: "credential_store_invalid", exitCode: EXIT.AUTH });
+  }
+  const profileName = String(parsed.active_profile || "default");
+  const profile = parsed.profiles?.[profileName];
+  const key = String(profile?.api_key || "").trim();
+  if (!key.startsWith("cvk_")) {
+    throw new CliError("Stored Corvio credentials are invalid; run `corvio auth login` again.", {
+      code: "credential_store_invalid",
+      exitCode: EXIT.AUTH,
+    });
+  }
+  return { key, source: "device_link", profile: profileName, metadata: profile };
+}
+
+export async function storeWorkspaceCredential(payload, env = process.env) {
+  const path = workspaceCredentialPath(env);
+  const root = dirname(path);
+  await mkdir(root, { recursive: true, mode: 0o700 });
+  await chmod(root, 0o700).catch(() => {});
+  const profileName = String(payload.workspace_id || "default");
+  const document = {
+    version: 1,
+    active_profile: profileName,
+    profiles: {
+      [profileName]: {
+        api_key: payload.secret,
+        key_id: payload.key_id,
+        workspace_id: payload.workspace_id,
+        workspace_name: payload.workspace_name,
+        scopes: payload.scopes || [],
+        created_at: payload.created_at || new Date().toISOString(),
+        source: "device_link",
+      },
+    },
+  };
+  const temporary = `${path}.${randomUUID()}.tmp`;
+  await writeFile(temporary, `${JSON.stringify(document, null, 2)}\n`, { mode: 0o600, flag: "wx" });
+  await chmod(temporary, 0o600);
+  await rename(temporary, path);
+  await chmod(path, 0o600);
+  return { path, profile: profileName };
+}
+
+export async function clearWorkspaceCredential(env = process.env) {
+  const path = workspaceCredentialPath(env);
+  await rm(path, { force: true });
+  return path;
+}
+
+export function readAdminCredential(env = process.env) {
+  const key = String(env.CORVIO_ADMIN_API_KEY || "").trim();
+  if (!key) return null;
+  if (!key.startsWith("cva_")) {
+    throw new CliError("CORVIO_ADMIN_API_KEY must be a platform administrator cva_ key.", {
+      code: "invalid_admin_key",
+      exitCode: EXIT.AUTH,
+    });
+  }
+  return { key, source: "environment" };
+}
+
+export function writeResult(value, { json = false, stdout = process.stdout } = {}) {
+  if (json || typeof value !== "string") {
+    stdout.write(`${JSON.stringify(value, null, json ? 2 : 0)}\n`);
+  } else {
+    stdout.write(`${value}\n`);
+  }
+}
+
+export function writeError(error, { json = false, stderr = process.stderr } = {}) {
+  const safe = {
+    error: {
+      code: error instanceof CliError ? error.code : "unexpected_error",
+      message: error instanceof Error ? error.message : String(error),
+      ...(error instanceof CliError && error.status ? { status: error.status } : {}),
+      ...(error instanceof CliError && error.details ? { details: error.details } : {}),
+    },
+  };
+  stderr.write(json ? `${JSON.stringify(safe)}\n` : `Error: ${safe.error.message}\n`);
+}
+
+export async function runMain(main, argv = process.argv.slice(2)) {
+  let json = argv.includes("--json");
+  try {
+    const parsed = parseArgv(argv);
+    json = Boolean(parsed.options.json);
+    await main(parsed);
+  } catch (error) {
+    writeError(error, { json });
+    process.exitCode = error instanceof CliError ? error.exitCode : 1;
+  }
+}
+
+export async function openBrowser(url) {
+  const target = String(url);
+  const command = platform() === "darwin" ? "open" : platform() === "win32" ? "cmd" : "xdg-open";
+  const args = platform() === "win32" ? ["/c", "start", "", target] : [target];
+  try {
+    const child = spawn(command, args, { detached: true, stdio: "ignore" });
+    child.unref();
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+export async function sleep(milliseconds) {
+  await new Promise((resolvePromise) => setTimeout(resolvePromise, milliseconds));
+}
+
+export async function readTextFile(path) {
+  return readFile(resolve(String(path)), "utf8");
+}
+
+export async function writeTextFile(path, content) {
+  const target = resolve(String(path));
+  await mkdir(dirname(target), { recursive: true });
+  await writeFile(target, content, "utf8");
+  return target;
+}
+
+export function requireConfirmation(options, action) {
+  if (!options.yes) {
+    throw new CliError(`${action} requires --yes.`, { code: "confirmation_required" });
+  }
+}
+
+export function idempotencyKey(options) {
+  return String(options["idempotency-key"] || randomUUID());
+}

package/package.json

@@ -0,0 +1,40 @@
+{
+  "name": "@corvio/cli",
+  "version": "0.1.0-beta.2",
+  "description": "Official Corvio Workspace CLI for questions, knowledge search, documents, and Agent workflows.",
+  "type": "module",
+  "bin": {
+    "corvio": "dist/cli.js"
+  },
+  "files": [
+    "dist",
+    "README.md"
+  ],
+  "scripts": {
+    "prepack": "node ../../scripts/build.mjs workspace"
+  },
+  "engines": {
+    "node": ">=20.11"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "license": "UNLICENSED",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/NeoFlux-AI/corvio.git",
+    "directory": "developer-cli/packages/workspace"
+  },
+  "homepage": "https://corvio.ai/developers/cli",
+  "bugs": {
+    "url": "https://github.com/NeoFlux-AI/corvio/issues"
+  },
+  "keywords": [
+    "corvio",
+    "cli",
+    "workspace",
+    "second-brain",
+    "codex",
+    "claude-code"
+  ]
+}