@lunnoa/client 1.1.0 → 1.3.0

package/dist/cli.js

@@ -430,10 +430,7 @@ var AgentChatClient = class {
         raw: true,
         signal: options.signal,
         headers: { Accept: "text/event-stream" },
-        body: {
-          messages: [uiMessage],
-          ...options.chatMode ? { chatMode: options.chatMode } : {}
-        }
+        body: messageTaskBody(uiMessage, options)
       }
     );
     return new AgentChatStream(response, { signal: options.signal });
@@ -472,6 +469,14 @@ var AgentChatClient = class {
     );
   }
 };
+function messageTaskBody(message, options = {}) {
+  return {
+    messages: [message],
+    ...options.chatMode ? { chatMode: options.chatMode } : {},
+    ...options.data ? { data: options.data } : {},
+    ...options.piiResolution ? { piiResolution: options.piiResolution } : {}
+  };
+}
 function generateMessageId() {
   const cryptoObj = globalThis.crypto;
   if (cryptoObj?.randomUUID) {
@@ -1005,7 +1010,6 @@ var EntitiesResource = class {
       objectTypeSlug: options.objectTypeSlug,
       state: options.state,
       states: options.states?.join(","),
-      ownerId: options.ownerId,
       search: options.search,
       sortBy: options.sortBy,
       sortOrder: options.sortOrder,
@@ -1601,10 +1605,11 @@ var QueueItemsResource = class {
   listRetryable(queueId) {
     return this.http.get(`/api/queues/${queueId}/items/retry`);
   }
-  /** Returns items with the given status. */
-  listByStatus(queueId, status) {
+  /** Returns a page of items with the given status. */
+  listByStatus(queueId, status, options = {}) {
     return this.http.get(
-      `/api/queues/${queueId}/items/status/${status}`
+      `/api/queues/${queueId}/items/status/${status}`,
+      { query: { limit: options.limit, offset: options.offset } }
     );
   }
   /** Looks an item up by the external ID your system supplied. */
@@ -1613,11 +1618,22 @@ var QueueItemsResource = class {
       `/api/queues/${queueId}/items/external/${externalId}`
     );
   }
-  /** Searches items in the queue. */
-  search(queueId, query) {
-    return this.http.get(`/api/queues/${queueId}/items/search`, {
-      query: { q: query }
-    });
+  /**
+   * Searches items by external id, item data, and metadata.
+   * Returns one page, same shape as `list`.
+   */
+  search(queueId, query, options = {}) {
+    return this.http.get(
+      `/api/queues/${queueId}/items/search`,
+      {
+        query: {
+          limit: options.limit,
+          offset: options.offset,
+          expansion: serializeCsv(options.expansion),
+          filterBy: serializeFilterBy({ search: query })
+        }
+      }
+    );
   }
   /** Returns per-status and per-priority counts for the queue. */
   stats(queueId) {
@@ -1653,10 +1669,21 @@ var QueueItemsResource = class {
   addError(queueId, itemId, error) {
     return this.http.post(
       `/api/queues/${queueId}/items/${itemId}/error`,
-      { body: error }
+      {
+        body: {
+          error: error.error,
+          errorDetails: serializeErrorDetails(error.errorDetails)
+        }
+      }
     );
   }
 };
+function serializeErrorDetails(value) {
+  if (value === void 0) {
+    return void 0;
+  }
+  return typeof value === "string" ? value : JSON.stringify(value);
+}
 
 // src/resources/queues.ts
 var QueuesResource = class {
@@ -1783,6 +1810,32 @@ var RunsResource = class {
   }
 };
 
+// src/resources/scorecards.ts
+var ScorecardsResource = class {
+  constructor(http) {
+    this.http = http;
+  }
+  http;
+  /** Lists scorecards in the workspace. */
+  list() {
+    return this.http.get("/api/scorecards");
+  }
+  /** Returns a scorecard with objectives, measures, latest values and status. */
+  get(scorecardId) {
+    return this.http.get(`/api/scorecards/${scorecardId}`);
+  }
+  /**
+   * Records a measure value. A value for the same period replaces the current
+   * one; the old value is kept as superseded history.
+   */
+  recordValue(measureId, data) {
+    return this.http.post(
+      `/api/scorecards/measures/${measureId}/values`,
+      { body: data }
+    );
+  }
+};
+
 // src/resources/tasks.ts
 var TasksResource = class {
   constructor(http) {
@@ -1833,12 +1886,7 @@ var TasksResource = class {
     } : message;
     return this.http.post(
       `/api/agents/${agentId}/tasks/${taskId}/message`,
-      {
-        body: {
-          messages: [uiMessage],
-          ...options.chatMode ? { chatMode: options.chatMode } : {}
-        }
-      }
+      { body: messageTaskBody(uiMessage, options) }
     );
   }
 };
@@ -2021,6 +2069,7 @@ var LunnoaClient = class {
   queues;
   queueItems;
   variables;
+  scorecards;
   connections;
   projects;
   workflowApps;
@@ -2043,12 +2092,653 @@ var LunnoaClient = class {
     this.queues = new QueuesResource(this.http);
     this.queueItems = new QueueItemsResource(this.http);
     this.variables = new VariablesResource(this.http);
+    this.scorecards = new ScorecardsResource(this.http);
     this.connections = new ConnectionsResource(this.http);
     this.projects = new ProjectsResource(this.http);
     this.discovery = new DiscoveryResource(this.http);
   }
 };
 
+// src/cli/args.ts
+var GROUPS_WITH_SUBCOMMAND = /* @__PURE__ */ new Set([
+  "workflows",
+  "agents",
+  "entity-types",
+  "tools",
+  "apps",
+  "connections",
+  "projects"
+]);
+var VALUE_FLAGS = /* @__PURE__ */ new Set([
+  "--url",
+  "--api-key",
+  "--access-token",
+  "--project-id",
+  "--out",
+  "--app"
+]);
+function requireFlagValue(flag, value) {
+  if (!value || value.startsWith("--")) {
+    throw new Error(`Missing value for ${flag}`);
+  }
+  return value;
+}
+function parseArgs(argv) {
+  const args = {
+    command: argv[0],
+    out: "./src/lunnoa",
+    json: false,
+    forAgent: false,
+    help: false
+  };
+  let i = 1;
+  if (args.command && GROUPS_WITH_SUBCOMMAND.has(args.command)) {
+    const next = argv[1];
+    if (next && !next.startsWith("--")) {
+      args.subcommand = next;
+      i = 2;
+      if (argv[2] && !argv[2].startsWith("--")) {
+        args.path = argv[2];
+        i = 3;
+      }
+    }
+  }
+  for (; i < argv.length; i += 1) {
+    const flag = argv[i];
+    if (flag === "--help" || flag === "-h") {
+      args.help = true;
+      continue;
+    }
+    if (flag === "--json") {
+      args.json = true;
+      continue;
+    }
+    if (flag === "--for-agent") {
+      args.forAgent = true;
+      continue;
+    }
+    if (flag && VALUE_FLAGS.has(flag)) {
+      const value = requireFlagValue(flag, argv[i + 1]);
+      switch (flag) {
+        case "--url":
+          args.url = value;
+          break;
+        case "--api-key":
+          args.apiKey = value;
+          break;
+        case "--access-token":
+          args.accessToken = value;
+          break;
+        case "--project-id":
+          args.projectId = value;
+          break;
+        case "--out":
+          args.out = value;
+          break;
+        case "--app":
+          args.app = value;
+          break;
+        default:
+          break;
+      }
+      i += 1;
+      continue;
+    }
+    if (flag && !flag.startsWith("--") && !args.path) {
+      args.path = flag;
+      continue;
+    }
+    throw new Error(`Unknown option: ${flag}`);
+  }
+  return args;
+}
+var USAGE = `Usage:
+  npx @lunnoa/client codegen --url <url> --api-key <lna_key> [--out <dir>]
+
+  Discover (do not invent catalogue action ids):
+  npx @lunnoa/client tools list [--app <appId>] [--for-agent] [--json]
+  npx @lunnoa/client tools get <actionId> [--app <appId>] [--json]
+  npx @lunnoa/client tools search <query> [--app <appId>] [--for-agent] [--json]
+  npx @lunnoa/client apps list [--for-agent] [--json]
+  npx @lunnoa/client apps get <appId> [--json]
+  npx @lunnoa/client connections list [--app <appId>] [--json]
+  npx @lunnoa/client connections get <connectionId> [--json]
+  npx @lunnoa/client agents list [--json]
+  npx @lunnoa/client workflows list [--json]
+  npx @lunnoa/client entity-types list [--json]
+  npx @lunnoa/client projects list [--json]
+  npx @lunnoa/client features [--json]
+
+  Deploy (upsert by slug):
+  npx @lunnoa/client workflows deploy <path> --url <url> --api-key <key> --project-id <uuid>
+  npx @lunnoa/client agents deploy <path> --url <url> --api-key <key> --project-id <uuid>
+  npx @lunnoa/client entity-types deploy <path> --url <url> --api-key <key>
+
+Options:
+  --url           Base URL of the Lunnoa Automate deployment
+  --api-key       Machine API key (lna_...)
+  --access-token  User JWT as an alternative to --api-key
+  --project-id    Project UUID (required for workflow/agent deploy)
+  --out           Output directory for lunnoa.generated.ts (codegen; default: ./src/lunnoa)
+  --app           Restrict tools/connections to one workflow app id
+  --for-agent     Only catalogue entries with availableForAgent
+  --json          Machine-readable JSON (preferred for coding agents)
+  --help          Show this help
+
+Environment: LUNNOA_URL, LUNNOA_API_KEY, LUNNOA_PROJECT_ID
+Optional config file: lunnoa.config.ts | .mjs | .js | .json
+
+tools get prints inputConfig and a defineAction() sketch. tools list is compact;
+run tools get for the schema. Entity-type deploy is workspace-scoped (no
+--project-id). Unknown instance attributes are rejected unless
+allowUnknownAttributes is true; use extensions.
+`;
+
+// src/cli/catalog.ts
+function asRecord(value) {
+  if (value && typeof value === "object" && !Array.isArray(value)) {
+    return value;
+  }
+  return void 0;
+}
+function flattenActions(apps) {
+  const out = [];
+  for (const app of apps) {
+    const appId = typeof app.id === "string" ? app.id : "";
+    if (!appId) {
+      continue;
+    }
+    const actions = Array.isArray(app.actions) ? app.actions : [];
+    for (const raw of actions) {
+      const action = asRecord(raw);
+      if (!action || typeof action.id !== "string" || !action.id) {
+        continue;
+      }
+      const actionId = action.id;
+      out.push({
+        appId,
+        appName: typeof app.name === "string" ? app.name : appId,
+        actionId,
+        name: typeof action.name === "string" ? action.name : actionId,
+        description: typeof action.description === "string" ? action.description : "",
+        availableForAgent: typeof action.availableForAgent === "boolean" ? action.availableForAgent : Boolean(app.availableForAgent),
+        needsConnection: typeof action.needsConnection === "boolean" ? action.needsConnection : Boolean(app.needsConnection),
+        inputConfig: action.inputConfig
+      });
+    }
+  }
+  return out;
+}
+function filterActions(actions, filter = {}) {
+  const appId = filter.appId?.trim();
+  const query = filter.query?.trim().toLowerCase();
+  return actions.filter((action) => {
+    if (appId && action.appId !== appId) {
+      return false;
+    }
+    if (filter.forAgent && !action.availableForAgent) {
+      return false;
+    }
+    if (query) {
+      const haystack = [
+        action.appId,
+        action.appName,
+        action.actionId,
+        action.name,
+        action.description
+      ].join(" ").toLowerCase();
+      if (!haystack.includes(query)) {
+        return false;
+      }
+    }
+    return true;
+  });
+}
+function parseActionRef(raw) {
+  const trimmed = raw.trim();
+  const dot = trimmed.indexOf(".");
+  if (dot > 0) {
+    const maybeApp = trimmed.slice(0, dot);
+    const maybeAction = trimmed.slice(dot + 1);
+    if (maybeApp && maybeAction && !maybeApp.includes("_action_")) {
+      return { appId: maybeApp, actionId: maybeAction };
+    }
+  }
+  return { actionId: trimmed };
+}
+function resolveAction(actions, rawRef, appId) {
+  const parsed = parseActionRef(rawRef);
+  const scope = appId?.trim() || parsed.appId;
+  const matches = actions.filter((action) => {
+    if (action.actionId !== parsed.actionId) {
+      return false;
+    }
+    return scope ? action.appId === scope : true;
+  });
+  if (matches.length === 1) {
+    return matches[0];
+  }
+  if (matches.length === 0) {
+    const hint = scope ? `No action "${parsed.actionId}" on app "${scope}". Try: tools search ${parsed.actionId}` : `Unknown action "${parsed.actionId}". Try: tools search ${parsed.actionId}`;
+    throw new Error(hint);
+  }
+  const apps = matches.map((m) => m.appId).join(", ");
+  throw new Error(
+    `Action "${parsed.actionId}" exists on multiple apps (${apps}). Pass --app <appId>.`
+  );
+}
+function extractInputFields(inputConfig) {
+  if (!inputConfig) {
+    return [];
+  }
+  if (Array.isArray(inputConfig)) {
+    return inputConfig.map((item) => fieldFromUnknown(item)).filter((field) => Boolean(field));
+  }
+  const record = asRecord(inputConfig);
+  if (!record) {
+    return [];
+  }
+  if (Array.isArray(record.fields)) {
+    return extractInputFields(record.fields);
+  }
+  if (Array.isArray(record.sections)) {
+    return record.sections.flatMap((section) => {
+      const sectionRecord = asRecord(section);
+      return extractInputFields(sectionRecord?.fields ?? section);
+    });
+  }
+  return Object.entries(record).filter(([, value]) => value === null || typeof value !== "object" || !Array.isArray(value)).map(([id, value]) => {
+    const field = asRecord(value);
+    if (!field) {
+      return { id };
+    }
+    return {
+      id: typeof field.id === "string" ? field.id : id,
+      label: typeof field.label === "string" ? field.label : void 0,
+      type: typeof field.type === "string" ? field.type : typeof field.inputType === "string" ? field.inputType : void 0,
+      required: typeof field.required === "boolean" ? field.required : void 0
+    };
+  });
+}
+function fieldFromUnknown(value) {
+  const field = asRecord(value);
+  if (!field || typeof field.id !== "string" || !field.id) {
+    return void 0;
+  }
+  return {
+    id: field.id,
+    label: typeof field.label === "string" ? field.label : void 0,
+    type: typeof field.type === "string" ? field.type : typeof field.inputType === "string" ? field.inputType : void 0,
+    required: typeof field.required === "boolean" ? field.required : void 0
+  };
+}
+function summarizeAction(action) {
+  return {
+    appId: action.appId,
+    actionId: action.actionId,
+    name: action.name,
+    description: action.description,
+    availableForAgent: action.availableForAgent,
+    needsConnection: action.needsConnection
+  };
+}
+function formatDefineActionSnippet(action) {
+  const fields = extractInputFields(action.inputConfig);
+  const inputBlock = fields.length === 0 ? "    // no inputConfig fields advertised" : fields.map((field) => {
+    const notes = [
+      field.label && field.label !== field.id ? field.label : void 0,
+      field.type,
+      field.required ? "required" : void 0
+    ].filter(Boolean).join(", ");
+    return notes ? `    // ${field.id}${notes ? ` \u2014 ${notes}` : ""}` : `    // ${field.id}`;
+  }).join("\n");
+  return [
+    "defineAction({",
+    `  id: '${action.actionId}',`,
+    `  appId: '${action.appId}',`,
+    "  input: {",
+    inputBlock,
+    "  },",
+    "})"
+  ].join("\n");
+}
+function actionDetail(action) {
+  return {
+    ...summarizeAction(action),
+    inputFields: extractInputFields(action.inputConfig),
+    inputConfig: action.inputConfig ?? null,
+    defineAction: formatDefineActionSnippet(action)
+  };
+}
+
+// src/cli/print.ts
+function printJson(value) {
+  console.log(JSON.stringify(value, null, 2));
+}
+function formatTable(rows, columns) {
+  if (rows.length === 0) {
+    return "No results.";
+  }
+  const widths = columns.map((col) => {
+    let width = col.header.length;
+    for (const row of rows) {
+      width = Math.max(width, stringifyCell(row[col.key]).length);
+    }
+    return width;
+  });
+  const header = columns.map((col, i) => pad(col.header, widths[i])).join("  ");
+  const divider = widths.map((w) => "-".repeat(w)).join("  ");
+  const body = rows.map(
+    (row) => columns.map((col, i) => pad(stringifyCell(row[col.key]), widths[i])).join("  ")
+  );
+  return [header, divider, ...body].join("\n");
+}
+function printTable(rows, columns) {
+  console.log(formatTable(rows, columns));
+}
+function stringifyCell(value) {
+  if (value === null || value === void 0) {
+    return "";
+  }
+  if (typeof value === "boolean") {
+    return value ? "yes" : "no";
+  }
+  return String(value);
+}
+function pad(value, width) {
+  return value.length >= width ? value : `${value}${" ".repeat(width - value.length)}`;
+}
+
+// src/cli/discover.ts
+function requireTarget(args, label) {
+  const value = args.path?.trim();
+  if (!value) {
+    throw new Error(`Missing ${label}.`);
+  }
+  return value;
+}
+async function loadCatalog(client) {
+  return flattenActions(await client.workflowApps.list());
+}
+async function runToolsList(client, args) {
+  const actions = filterActions(await loadCatalog(client), {
+    appId: args.app,
+    forAgent: args.forAgent
+  });
+  const rows = actions.map(summarizeAction);
+  if (args.json) {
+    printJson(rows);
+    return;
+  }
+  printTable(rows, [
+    { key: "appId", header: "APP" },
+    { key: "actionId", header: "ACTION" },
+    { key: "name", header: "NAME" },
+    { key: "availableForAgent", header: "FOR_AGENT" },
+    { key: "needsConnection", header: "NEEDS_CONN" }
+  ]);
+}
+async function runToolsGet(client, args) {
+  const ref = requireTarget(args, "action id (example: tools get http_action_send-request)");
+  const action = resolveAction(await loadCatalog(client), ref, args.app);
+  const detail = actionDetail(action);
+  if (args.json) {
+    printJson(detail);
+    return;
+  }
+  console.log(`appId:             ${detail.appId}`);
+  console.log(`actionId:          ${detail.actionId}`);
+  console.log(`name:              ${detail.name}`);
+  if (detail.description) {
+    console.log(`description:       ${detail.description}`);
+  }
+  console.log(`availableForAgent: ${detail.availableForAgent ? "yes" : "no"}`);
+  console.log(`needsConnection:   ${detail.needsConnection ? "yes" : "no"}`);
+  console.log("");
+  console.log("inputFields:");
+  if (detail.inputFields.length === 0) {
+    console.log("  (none advertised)");
+  } else {
+    for (const field of detail.inputFields) {
+      const bits = [
+        field.label && field.label !== field.id ? field.label : void 0,
+        field.type,
+        field.required ? "required" : void 0
+      ].filter(Boolean);
+      console.log(`  ${field.id}${bits.length ? `  (${bits.join(", ")})` : ""}`);
+    }
+  }
+  console.log("");
+  console.log("defineAction:");
+  console.log(detail.defineAction);
+}
+async function runToolsSearch(client, args) {
+  const query = requireTarget(args, "search query (example: tools search email)");
+  const actions = filterActions(await loadCatalog(client), {
+    appId: args.app,
+    forAgent: args.forAgent,
+    query
+  });
+  const rows = actions.map(summarizeAction);
+  if (args.json) {
+    printJson(rows);
+    return;
+  }
+  printTable(rows, [
+    { key: "appId", header: "APP" },
+    { key: "actionId", header: "ACTION" },
+    { key: "name", header: "NAME" },
+    { key: "availableForAgent", header: "FOR_AGENT" },
+    { key: "needsConnection", header: "NEEDS_CONN" }
+  ]);
+}
+async function runAppsList(client, args) {
+  const apps = await client.workflowApps.list();
+  const rows = apps.filter((app) => args.forAgent ? Boolean(app.availableForAgent) : true).filter((app) => args.app ? app.id === args.app : true).map((app) => ({
+    id: app.id ?? "",
+    name: app.name ?? app.id ?? "",
+    availableForAgent: Boolean(app.availableForAgent),
+    needsConnection: Boolean(app.needsConnection),
+    actions: Array.isArray(app.actions) ? app.actions.length : 0
+  }));
+  if (args.json) {
+    printJson(rows);
+    return;
+  }
+  printTable(rows, [
+    { key: "id", header: "APP" },
+    { key: "name", header: "NAME" },
+    { key: "availableForAgent", header: "FOR_AGENT" },
+    { key: "needsConnection", header: "NEEDS_CONN" },
+    { key: "actions", header: "ACTIONS" }
+  ]);
+}
+async function runAppsGet(client, args) {
+  const appId = requireTarget(args, "app id (example: apps get http)");
+  const apps = await client.workflowApps.list();
+  const app = apps.find((item) => item.id === appId);
+  if (!app) {
+    throw new Error(`Unknown app "${appId}". Try: apps list`);
+  }
+  const actions = flattenActions([app]).map(summarizeAction);
+  const payload = {
+    id: app.id,
+    name: app.name,
+    description: app.description ?? "",
+    availableForAgent: Boolean(app.availableForAgent),
+    needsConnection: Boolean(app.needsConnection),
+    isPublished: Boolean(app.isPublished),
+    actions,
+    connectionTypes: Array.isArray(app.connections) ? app.connections : []
+  };
+  if (args.json) {
+    printJson(payload);
+    return;
+  }
+  console.log(`id:                ${payload.id}`);
+  console.log(`name:              ${payload.name}`);
+  if (payload.description) {
+    console.log(`description:       ${payload.description}`);
+  }
+  console.log(`availableForAgent: ${payload.availableForAgent ? "yes" : "no"}`);
+  console.log(`needsConnection:   ${payload.needsConnection ? "yes" : "no"}`);
+  console.log("");
+  printTable(actions, [
+    { key: "actionId", header: "ACTION" },
+    { key: "name", header: "NAME" },
+    { key: "availableForAgent", header: "FOR_AGENT" },
+    { key: "needsConnection", header: "NEEDS_CONN" }
+  ]);
+}
+async function runConnectionsList(client, args) {
+  const connections = await client.connections.list({
+    expansion: ["workflowAppId", "connectionId", "createdAt"]
+  });
+  const rows = connections.filter(
+    (connection) => args.app ? connection.workflowAppId === args.app : true
+  ).map((connection) => ({
+    id: connection.id,
+    name: connection.name,
+    workflowAppId: connection.workflowAppId ?? "",
+    connectionId: connection.connectionId ?? ""
+  }));
+  if (args.json) {
+    printJson(rows);
+    return;
+  }
+  printTable(rows, [
+    { key: "id", header: "ID" },
+    { key: "name", header: "NAME" },
+    { key: "workflowAppId", header: "APP" },
+    { key: "connectionId", header: "TYPE" }
+  ]);
+}
+async function runConnectionsGet(client, args) {
+  const id = requireTarget(args, "connection id (example: connections get <uuid>)");
+  const connection = await client.connections.get(id, {
+    expansion: ["workflowAppId", "connectionId", "createdAt", "updatedAt"]
+  });
+  const payload = {
+    id: connection.id,
+    name: connection.name,
+    workflowAppId: connection.workflowAppId ?? null,
+    connectionId: connection.connectionId ?? null,
+    createdAt: connection.createdAt ?? null,
+    updatedAt: connection.updatedAt ?? null
+  };
+  if (args.json) {
+    printJson(payload);
+    return;
+  }
+  console.log(`id:            ${payload.id}`);
+  console.log(`name:          ${payload.name}`);
+  console.log(`workflowAppId: ${payload.workflowAppId ?? ""}`);
+  console.log(`connectionId:  ${payload.connectionId ?? ""}`);
+}
+async function runAgentsList(client, args) {
+  const agents = await client.agents.list({
+    expansion: ["description", "slug", "managedByCode"]
+  });
+  const rows = agents.map((agent) => ({
+    id: agent.id,
+    name: agent.name,
+    slug: agent.slug ?? "",
+    managedByCode: Boolean(agent.managedByCode),
+    description: agent.description ?? ""
+  }));
+  if (args.json) {
+    printJson(rows);
+    return;
+  }
+  printTable(rows, [
+    { key: "id", header: "ID" },
+    { key: "slug", header: "SLUG" },
+    { key: "name", header: "NAME" },
+    { key: "managedByCode", header: "CODE" }
+  ]);
+}
+async function runWorkflowsList(client, args) {
+  const workflows = await client.workflows.list({
+    expansion: ["description", "isActive", "slug", "managedByCode"]
+  });
+  const rows = workflows.map((workflow) => ({
+    id: workflow.id,
+    name: workflow.name,
+    slug: workflow.slug ?? "",
+    isActive: Boolean(workflow.isActive),
+    managedByCode: Boolean(workflow.managedByCode)
+  }));
+  if (args.json) {
+    printJson(rows);
+    return;
+  }
+  printTable(rows, [
+    { key: "id", header: "ID" },
+    { key: "slug", header: "SLUG" },
+    { key: "name", header: "NAME" },
+    { key: "isActive", header: "ACTIVE" },
+    { key: "managedByCode", header: "CODE" }
+  ]);
+}
+async function runEntityTypesList(client, args) {
+  const types = await client.entityTypes.list({
+    expansion: ["description"]
+  });
+  const rows = types.map((type) => ({
+    id: type.id,
+    slug: type.slug,
+    name: type.name,
+    managedByCode: Boolean(type.managedByCode)
+  }));
+  if (args.json) {
+    printJson(rows);
+    return;
+  }
+  printTable(rows, [
+    { key: "id", header: "ID" },
+    { key: "slug", header: "SLUG" },
+    { key: "name", header: "NAME" },
+    { key: "managedByCode", header: "CODE" }
+  ]);
+}
+async function runProjectsList(client, args) {
+  const projects = await client.projects.list({
+    expansion: ["description", "countAgents", "countWorkflows"]
+  });
+  const rows = projects.map((project) => ({
+    id: project.id,
+    name: project.name,
+    description: project.description ?? "",
+    agents: project._count?.agents ?? "",
+    workflows: project._count?.workflows ?? ""
+  }));
+  if (args.json) {
+    printJson(rows);
+    return;
+  }
+  printTable(rows, [
+    { key: "id", header: "ID" },
+    { key: "name", header: "NAME" },
+    { key: "agents", header: "AGENTS" },
+    { key: "workflows", header: "WORKFLOWS" }
+  ]);
+}
+async function runFeatures(client, args) {
+  const features = await client.discovery.enabledFeatures();
+  if (args.json) {
+    printJson(features);
+    return;
+  }
+  const rows = Object.entries(features).filter(([, value]) => typeof value === "boolean").map(([key, value]) => ({
+    feature: key,
+    enabled: value
+  }));
+  printTable(rows, [
+    { key: "feature", header: "FEATURE" },
+    { key: "enabled", header: "ENABLED" }
+  ]);
+}
+
 // src/cli/generate.ts
 function computeDeploymentSchemaFingerprint(entityTypes) {
   const parts = [...entityTypes].map((type) => {
@@ -2191,7 +2881,7 @@ function generateDeploymentModule(definitions) {
  *
  * Schema fingerprint: ${schemaFingerprint}
  */
-import type { LunnoaClient, Entity, Execution, ExecuteWorkflowResult, PaginatedEntities, Task, AgentChatStream, WaitUntilFinishedOptions, ListEntitiesOptions, UIMessage } from '@lunnoa/client';
+import type { LunnoaClient, Entity, Execution, ExecuteWorkflowResult, PaginatedEntities, Task, AgentChatStream, WaitUntilFinishedOptions, ListEntitiesOptions, StreamMessageOptions, UIMessage } from '@lunnoa/client';
 
 /** Fingerprint of entity-type schemas at codegen time (slug:revision:allowUnknown). */
 export const DEPLOYMENT_SCHEMA_FINGERPRINT = ${JSON.stringify(schemaFingerprint)};
@@ -2379,7 +3069,7 @@ function typedEntityAccessor<A, S extends string>(
       })) as Typed;
     },
     /** Creates an entity of this type with compile-time checked attributes. */
-    async create(data: { name: string; attributes?: A; state?: S; ownerId?: string }): Promise<Typed> {
+    async create(data: { name: string; attributes?: A; state?: S }): Promise<Typed> {
       return (await client.entities.create(
         { ...data, objectTypeId } as never,
         { expansion: ['attributes'] },
@@ -2388,7 +3078,7 @@ function typedEntityAccessor<A, S extends string>(
     /** Partially updates an entity of this type. */
     async update(
       entityId: string,
-      data: { name?: string; attributes?: Partial<A>; ownerId?: string },
+      data: { name?: string; attributes?: Partial<A> },
     ): Promise<Typed> {
       return (await client.entities.update(entityId, data as never, {
         expansion: ['attributes'],
@@ -2434,13 +3124,17 @@ function typedAgentAccessor(client: LunnoaClient, agentId: string) {
     streamMessage(
       taskId: string,
       message: string | UIMessage,
-      options?: { chatMode?: 'builder' | 'preview'; signal?: AbortSignal },
+      options?: StreamMessageOptions,
     ): Promise<AgentChatStream> {
       return client.agentChat.streamMessage(agentId, taskId, message, options);
     },
     /** Sends a message and waits for the full turn (non-streaming). */
-    message(taskId: string, message: string | UIMessage) {
-      return client.tasks.message(agentId, taskId, message);
+    message(
+      taskId: string,
+      message: string | UIMessage,
+      options?: Omit<StreamMessageOptions, 'signal'>,
+    ) {
+      return client.tasks.message(agentId, taskId, message, options);
     },
   };
 }
@@ -2537,70 +3231,6 @@ async function loadOptionalConfig() {
 }
 
 // src/cli/index.ts
-function parseArgs(argv) {
-  const args = { command: argv[0], out: "./src/lunnoa" };
-  let i = 1;
-  if (args.command === "workflows" || args.command === "agents" || args.command === "entity-types") {
-    args.subcommand = argv[1];
-    i = 2;
-    if (argv[2] && !argv[2].startsWith("--")) {
-      args.path = argv[2];
-      i = 3;
-    }
-  }
-  for (; i < argv.length; i += 1) {
-    const flag = argv[i];
-    const value = argv[i + 1];
-    switch (flag) {
-      case "--url":
-        args.url = value;
-        i += 1;
-        break;
-      case "--api-key":
-        args.apiKey = value;
-        i += 1;
-        break;
-      case "--access-token":
-        args.accessToken = value;
-        i += 1;
-        break;
-      case "--project-id":
-        args.projectId = value;
-        i += 1;
-        break;
-      case "--out":
-        args.out = value;
-        i += 1;
-        break;
-      default:
-        if (!args.path && !flag.startsWith("--")) {
-          args.path = flag;
-          break;
-        }
-        throw new Error(`Unknown option: ${flag}`);
-    }
-  }
-  return args;
-}
-var USAGE = `Usage:
-  npx @lunnoa/client codegen --url <deployment-url> --api-key <lna_key> [--out <dir>]
-  npx @lunnoa/client workflows deploy <path> --url <url> --api-key <key> --project-id <uuid>
-  npx @lunnoa/client agents deploy <path> --url <url> --api-key <key> --project-id <uuid>
-  npx @lunnoa/client entity-types deploy <path> --url <url> --api-key <key>
-
-Options:
-  --url           Base URL of the Lunnoa Automate deployment
-  --api-key       Machine API key (lna_...)
-  --access-token  User JWT as an alternative to --api-key
-  --project-id    Project UUID (required for workflow/agent deploy)
-  --out           Output directory for lunnoa.generated.ts (codegen; default: ./src/lunnoa)
-
-Environment: LUNNOA_URL, LUNNOA_API_KEY, LUNNOA_PROJECT_ID
-Optional config file: lunnoa.config.ts | .mjs | .js | .json
-
-Entity-type deploy is workspace-scoped (no --project-id). Unknown instance
-attributes are rejected unless allowUnknownAttributes is true; use extensions.
-`;
 async function bindClient(args) {
   const fileConfig = await loadOptionalConfig();
   const url = args.url ?? process.env.LUNNOA_URL ?? fileConfig.url;
@@ -2726,9 +3356,106 @@ async function deployEntityType(args) {
     `Upserted entity type ${result.id} (${payload.slug})` + (typeof result.schemaRevision === "number" ? ` schemaRevision=${result.schemaRevision}` : "")
   );
 }
+var DISCOVERY_SUBCOMMANDS = {
+  tools: ["list", "get", "search"],
+  apps: ["list", "get"],
+  connections: ["list", "get"],
+  features: void 0,
+  projects: ["list"]
+};
+function isDiscoveryCommand(args) {
+  const { command, subcommand } = args;
+  if (!command) {
+    return false;
+  }
+  if (command === "features") {
+    return true;
+  }
+  if (command === "projects" && (subcommand === "list" || !subcommand)) {
+    return true;
+  }
+  if ((command === "agents" || command === "workflows" || command === "entity-types") && subcommand === "list") {
+    return true;
+  }
+  const allowed = DISCOVERY_SUBCOMMANDS[command];
+  return Array.isArray(allowed) && Boolean(subcommand && allowed.includes(subcommand));
+}
+function assertKnownDiscoveryShape(args) {
+  const { command, subcommand } = args;
+  const allowed = command ? DISCOVERY_SUBCOMMANDS[command] : void 0;
+  if (!command || allowed === void 0) {
+    return;
+  }
+  if (!subcommand || !allowed.includes(subcommand)) {
+    throw new Error(
+      `Unknown command: ${command} ${subcommand ?? ""}
+
+${USAGE}`
+    );
+  }
+}
+async function runDiscovery(args) {
+  const { command, subcommand } = args;
+  if (command === "tools" || command === "apps" || command === "connections") {
+    assertKnownDiscoveryShape(args);
+  }
+  if (!isDiscoveryCommand(args)) {
+    return false;
+  }
+  const { client } = await bindClient(args);
+  if (command === "tools" && subcommand === "list") {
+    await runToolsList(client, args);
+    return true;
+  }
+  if (command === "tools" && subcommand === "get") {
+    await runToolsGet(client, args);
+    return true;
+  }
+  if (command === "tools" && subcommand === "search") {
+    await runToolsSearch(client, args);
+    return true;
+  }
+  if (command === "apps" && subcommand === "list") {
+    await runAppsList(client, args);
+    return true;
+  }
+  if (command === "apps" && subcommand === "get") {
+    await runAppsGet(client, args);
+    return true;
+  }
+  if (command === "connections" && subcommand === "list") {
+    await runConnectionsList(client, args);
+    return true;
+  }
+  if (command === "connections" && subcommand === "get") {
+    await runConnectionsGet(client, args);
+    return true;
+  }
+  if (command === "agents" && subcommand === "list") {
+    await runAgentsList(client, args);
+    return true;
+  }
+  if (command === "workflows" && subcommand === "list") {
+    await runWorkflowsList(client, args);
+    return true;
+  }
+  if (command === "entity-types" && subcommand === "list") {
+    await runEntityTypesList(client, args);
+    return true;
+  }
+  if (command === "projects" && (subcommand === "list" || !subcommand)) {
+    await runProjectsList(client, args);
+    return true;
+  }
+  if (command === "features") {
+    await runFeatures(client, args);
+    return true;
+  }
+  return false;
+}
 async function main() {
   const args = parseArgs(process.argv.slice(2));
-  if (!args.command || args.command === "--help" || args.command === "help") {
+  if (!args.command || args.command === "--help" || args.command === "help" || args.help) {
     console.log(USAGE);
     return;
   }
@@ -2736,6 +3463,9 @@ async function main() {
     await runCodegen(args);
     return;
   }
+  if (await runDiscovery(args)) {
+    return;
+  }
   if (args.command === "workflows" && args.subcommand === "deploy") {
     await deployWorkflow(args);
     return;