@topolo/cli 0.9.7 → 0.9.9

package/dist/index.js

@@ -9,7 +9,7 @@ import { platform as platform2 } from "os";
 import { createInterface } from "readline/promises";
 import { stdin as input } from "process";
 
-// node_modules/@topolo/sdk/dist/index.js
+// ../../../../../TopoloWork2/.worktrees/cli-postinstall-message/packages/topolo-cli/node_modules/@topolo/sdk/dist/index.js
 function applyAuthHeaders(headers, credential) {
   if (credential.kind === "api_key") {
     headers.set("X-Api-Key", credential.apiKey);
@@ -1836,12 +1836,21 @@ function redactActionResult(value) {
   if (!isRecord3(value)) return value;
   return Object.fromEntries(Object.entries(value).map(([key, item]) => [
     key,
-    isSensitiveActionResultKey(key) ? "[REDACTED]" : redactActionResult(item)
+    isSensitiveActionResultKey(key, item) ? "[REDACTED]" : redactActionResult(item)
   ]));
 }
-function isSensitiveActionResultKey(key) {
+function isSensitiveActionResultKey(key, value) {
   const normalized = key.toLowerCase().replace(/[^a-z0-9]/g, "");
-  return ["authorization", "cookie", "setcookie", "proxyauthorization", "capability"].includes(normalized) || /(token|secret|password|privatekey|apikey)$/.test(normalized);
+  if (normalized === "capability") return isCredentialShaped(value);
+  return ["authorization", "cookie", "setcookie", "proxyauthorization"].includes(normalized) || /(token|secret|password|privatekey|apikey)$/.test(normalized);
+}
+var PLAIN_ENUM_VALUE = /^[a-z][a-z0-9_-]{0,31}$/;
+function isCredentialShaped(value) {
+  if (typeof value !== "string") return value !== null && value !== void 0 && typeof value !== "boolean" && typeof value !== "number";
+  const trimmed = value.trim();
+  if (!trimmed) return false;
+  if (/^[a-z][a-z0-9+.-]*:\/\//i.test(trimmed)) return true;
+  return !PLAIN_ENUM_VALUE.test(trimmed);
 }
 function resolveConfiguredServiceUrl(slug, serviceUrls) {
   for (const serviceKey of serviceKeyCandidates2(slug)) {
@@ -2474,6 +2483,461 @@ var TopoloOAuth = class {
     return parsed;
   }
 };
+var nonEmptyString2 = { type: "string", minLength: 1 };
+var stringArray3 = { type: "array", items: nonEmptyString2 };
+var actionBinding = {
+  type: "object",
+  properties: {
+    id: nonEmptyString2,
+    label: nonEmptyString2,
+    actionId: nonEmptyString2,
+    resourceType: nonEmptyString2,
+    resourceId: nonEmptyString2,
+    input: { type: "object" },
+    requiresConfirmation: { type: "boolean" },
+    destructive: { type: "boolean" },
+    effects: stringArray3,
+    verification: stringArray3,
+    recovery: {
+      type: "object",
+      properties: {
+        mode: { enum: ["not_applicable", "retry", "compensating_action"] },
+        actionId: nonEmptyString2,
+        instructions: nonEmptyString2
+      },
+      required: ["mode", "instructions"],
+      additionalProperties: false
+    }
+  },
+  required: [
+    "id",
+    "label",
+    "actionId",
+    "resourceType",
+    "input",
+    "requiresConfirmation",
+    "destructive",
+    "effects",
+    "verification",
+    "recovery"
+  ],
+  additionalProperties: false
+};
+var dimension = {
+  type: "object",
+  properties: { key: nonEmptyString2, label: nonEmptyString2, value: nonEmptyString2 },
+  required: ["key", "label", "value"],
+  additionalProperties: false
+};
+var period = {
+  type: "object",
+  properties: {
+    start: nonEmptyString2,
+    end: nonEmptyString2,
+    timezone: nonEmptyString2
+  },
+  required: ["start", "end", "timezone"],
+  additionalProperties: false
+};
+var series = {
+  type: "object",
+  properties: {
+    id: nonEmptyString2,
+    label: nonEmptyString2,
+    unit: nonEmptyString2,
+    points: {
+      type: "array",
+      items: {
+        type: "object",
+        properties: {
+          timestamp: nonEmptyString2,
+          value: { type: "number" },
+          dimensions: { type: "array", items: dimension }
+        },
+        required: ["timestamp", "value", "dimensions"],
+        additionalProperties: false
+      }
+    }
+  },
+  required: ["id", "label", "unit", "points"],
+  additionalProperties: false
+};
+var contribution = {
+  type: "object",
+  properties: {
+    summary: nonEmptyString2,
+    identity: {
+      type: "object",
+      properties: { iconSource: { const: "catalog" } },
+      required: ["iconSource"],
+      additionalProperties: false
+    },
+    workspaceSelector: {
+      type: "object",
+      properties: {
+        mode: { enum: ["none", "optional", "required"] },
+        resourceType: nonEmptyString2,
+        label: nonEmptyString2,
+        supportsMultiple: { type: "boolean" }
+      },
+      required: ["mode", "resourceType", "label", "supportsMultiple"],
+      additionalProperties: false
+    },
+    metricDefinitions: {
+      type: "array",
+      items: {
+        type: "object",
+        properties: {
+          key: nonEmptyString2,
+          label: nonEmptyString2,
+          description: nonEmptyString2,
+          unit: nonEmptyString2,
+          semantic: {
+            enum: ["gauge", "counter", "rate", "duration", "currency", "percentage"]
+          },
+          aggregation: {
+            enum: ["last", "sum", "average", "minimum", "maximum", "count", "distinct_count"]
+          }
+        },
+        required: ["key", "label", "description", "unit", "semantic", "aggregation"],
+        additionalProperties: false
+      }
+    },
+    seriesDefinitions: {
+      type: "array",
+      items: {
+        type: "object",
+        properties: {
+          key: nonEmptyString2,
+          label: nonEmptyString2,
+          metricKey: nonEmptyString2,
+          unit: nonEmptyString2
+        },
+        required: ["key", "label", "metricKey", "unit"],
+        additionalProperties: false
+      }
+    },
+    dimensions: {
+      type: "array",
+      items: {
+        type: "object",
+        properties: {
+          key: nonEmptyString2,
+          label: nonEmptyString2,
+          description: nonEmptyString2,
+          valueType: { enum: ["string", "number", "boolean", "date", "datetime"] }
+        },
+        required: ["key", "label", "description", "valueType"],
+        additionalProperties: false
+      }
+    },
+    lifecycleStages: {
+      type: "array",
+      items: {
+        type: "object",
+        properties: {
+          key: nonEmptyString2,
+          label: nonEmptyString2,
+          order: { type: "number" },
+          terminal: { type: "boolean" }
+        },
+        required: ["key", "label", "order", "terminal"],
+        additionalProperties: false
+      }
+    },
+    events: {
+      type: "array",
+      items: {
+        type: "object",
+        properties: {
+          key: nonEmptyString2,
+          label: nonEmptyString2,
+          description: nonEmptyString2
+        },
+        required: ["key", "label", "description"],
+        additionalProperties: false
+      }
+    },
+    datasets: {
+      type: "array",
+      minItems: 1,
+      items: {
+        type: "object",
+        properties: {
+          id: nonEmptyString2,
+          label: nonEmptyString2,
+          description: nonEmptyString2,
+          grain: nonEmptyString2,
+          metricKeys: stringArray3,
+          seriesKeys: stringArray3,
+          dimensionKeys: stringArray3,
+          eventKeys: stringArray3,
+          actionIds: stringArray3
+        },
+        required: [
+          "id",
+          "label",
+          "description",
+          "grain",
+          "metricKeys",
+          "seriesKeys",
+          "dimensionKeys",
+          "eventKeys",
+          "actionIds"
+        ],
+        additionalProperties: false
+      }
+    },
+    compatibleVisualizations: {
+      type: "array",
+      minItems: 1,
+      items: {
+        enum: ["number", "line", "area", "bar", "donut", "table", "funnel", "timeline", "actions"]
+      }
+    },
+    defaultVisualization: {
+      enum: ["number", "line", "area", "bar", "donut", "table", "funnel", "timeline", "actions"]
+    }
+  },
+  required: [
+    "summary",
+    "identity",
+    "workspaceSelector",
+    "metricDefinitions",
+    "seriesDefinitions",
+    "dimensions",
+    "lifecycleStages",
+    "events",
+    "datasets",
+    "compatibleVisualizations",
+    "defaultVisualization"
+  ],
+  additionalProperties: false
+};
+var widgetItem = {
+  type: "object",
+  properties: {
+    id: nonEmptyString2,
+    version: nonEmptyString2,
+    appId: nonEmptyString2,
+    serviceName: nonEmptyString2,
+    lastUpdated: nonEmptyString2,
+    type: { enum: ["stats", "chart", "activity", "notifications", "actions"] },
+    presentation: {
+      type: "object",
+      properties: {
+        title: nonEmptyString2,
+        description: nonEmptyString2,
+        contexts: {
+          type: "array",
+          minItems: 1,
+          items: { enum: ["personal", "organization", "workspace", "resource"] }
+        },
+        supportedSizes: {
+          type: "array",
+          minItems: 1,
+          items: { enum: ["compact", "medium", "wide", "full"] }
+        },
+        defaultSize: { enum: ["compact", "medium", "wide", "full"] }
+      },
+      required: ["title", "contexts", "supportedSizes", "defaultSize"],
+      additionalProperties: false
+    },
+    resource: {
+      type: "object",
+      properties: {
+        resourceType: nonEmptyString2,
+        resourceId: nonEmptyString2,
+        requiredPermissions: stringArray3
+      },
+      required: ["resourceType", "requiredPermissions"],
+      additionalProperties: false
+    },
+    state: {
+      type: "object",
+      properties: {
+        status: { enum: ["ready", "empty", "unavailable", "stale", "error"] },
+        observedAt: nonEmptyString2,
+        lastSuccessfulAt: nonEmptyString2,
+        code: nonEmptyString2,
+        message: nonEmptyString2
+      },
+      required: ["status", "observedAt"],
+      additionalProperties: false
+    },
+    refresh: {
+      type: "object",
+      properties: {
+        intervalSeconds: { type: "number" },
+        timeoutSeconds: { type: "number" },
+        maxAgeSeconds: { type: "number" },
+        staleWhileRevalidateSeconds: { type: "number" }
+      },
+      required: ["intervalSeconds", "timeoutSeconds", "maxAgeSeconds", "staleWhileRevalidateSeconds"],
+      additionalProperties: false
+    },
+    configuration: {
+      type: "object",
+      properties: {
+        allowMultipleInstances: { type: "boolean" },
+        fields: {
+          type: "array",
+          items: {
+            type: "object",
+            properties: {
+              key: nonEmptyString2,
+              label: nonEmptyString2,
+              type: { enum: ["string", "number", "boolean", "select", "multi-select", "date-range"] },
+              required: { type: "boolean" },
+              options: {
+                type: "array",
+                items: {
+                  type: "object",
+                  properties: { value: nonEmptyString2, label: nonEmptyString2 },
+                  required: ["value", "label"],
+                  additionalProperties: false
+                }
+              }
+            },
+            required: ["key", "label", "type", "required"],
+            additionalProperties: false
+          }
+        },
+        defaults: { type: "object" }
+      },
+      required: ["allowMultipleInstances", "fields", "defaults"],
+      additionalProperties: false
+    },
+    drilldowns: {
+      type: "array",
+      items: {
+        type: "object",
+        properties: { id: nonEmptyString2, label: nonEmptyString2, href: nonEmptyString2 },
+        required: ["id", "label", "href"],
+        additionalProperties: false
+      }
+    },
+    controls: { type: "array", items: actionBinding },
+    localization: {
+      type: "object",
+      properties: {
+        locale: nonEmptyString2,
+        titleKey: nonEmptyString2,
+        descriptionKey: nonEmptyString2,
+        title: nonEmptyString2,
+        description: nonEmptyString2
+      },
+      required: ["locale", "titleKey"],
+      additionalProperties: false
+    },
+    accessibility: {
+      type: "object",
+      properties: { label: nonEmptyString2, description: nonEmptyString2 },
+      required: ["label"],
+      additionalProperties: false
+    },
+    contribution,
+    metrics: {
+      type: "array",
+      items: {
+        type: "object",
+        properties: {
+          key: nonEmptyString2,
+          label: nonEmptyString2,
+          value: { type: "number" },
+          unit: nonEmptyString2,
+          semantic: {
+            enum: ["gauge", "counter", "rate", "duration", "currency", "percentage"]
+          },
+          aggregation: {
+            enum: ["last", "sum", "average", "minimum", "maximum", "count", "distinct_count"]
+          },
+          period,
+          dimensions: { type: "array", items: dimension },
+          series
+        },
+        required: ["key", "label", "value", "unit", "semantic", "aggregation", "period", "dimensions"],
+        additionalProperties: false
+      }
+    },
+    chartType: { enum: ["line", "bar", "area", "pie", "donut"] },
+    series: { type: "array", items: series },
+    activities: { type: "array", items: { type: "object" } },
+    notifications: { type: "array", items: { type: "object" } },
+    unreadCount: { type: "number" },
+    actions: { type: "array", items: actionBinding }
+  },
+  required: [
+    "id",
+    "version",
+    "appId",
+    "serviceName",
+    "lastUpdated",
+    "type",
+    "presentation",
+    "resource",
+    "state",
+    "refresh",
+    "configuration",
+    "drilldowns",
+    "controls",
+    "localization",
+    "accessibility",
+    "contribution"
+  ],
+  allOf: [
+    { if: { properties: { type: { const: "stats" } } }, then: { required: ["metrics"] } },
+    { if: { properties: { type: { const: "chart" } } }, then: { required: ["chartType", "series"] } },
+    { if: { properties: { type: { const: "activity" } } }, then: { required: ["activities"] } },
+    {
+      if: { properties: { type: { const: "notifications" } } },
+      then: { required: ["notifications", "unreadCount"] }
+    },
+    { if: { properties: { type: { const: "actions" } } }, then: { required: ["actions"] } }
+  ],
+  additionalProperties: false
+};
+var TOPOLO_WIDGET_OUTPUT_SCHEMA = Object.freeze({
+  $schema: "https://json-schema.org/draft/2020-12/schema",
+  type: "object",
+  properties: {
+    success: { type: "boolean", const: true },
+    contractVersion: { type: "string", const: "3.0.0" },
+    appId: nonEmptyString2,
+    serviceName: nonEmptyString2,
+    generatedAt: nonEmptyString2,
+    widgets: { type: "array", minItems: 1, items: widgetItem },
+    workspace: {
+      anyOf: [
+        {
+          type: "object",
+          properties: {
+            id: { anyOf: [{ type: "string" }, { type: "number" }] },
+            name: nonEmptyString2
+          },
+          required: ["id", "name"],
+          additionalProperties: true
+        },
+        { type: "null" }
+      ]
+    },
+    workspaces: {
+      type: "array",
+      items: {
+        type: "object",
+        properties: {
+          id: { anyOf: [{ type: "string" }, { type: "number" }] },
+          name: nonEmptyString2,
+          isDefault: { type: "boolean" }
+        },
+        required: ["id", "name"],
+        additionalProperties: false
+      }
+    }
+  },
+  required: ["success", "contractVersion", "appId", "serviceName", "generatedAt", "widgets"],
+  additionalProperties: false
+});
 function createTopolo(options) {
   const client = new TopoloClient(options);
   return {
@@ -2484,7 +2948,7 @@ function createTopolo(options) {
   };
 }
 
-// node_modules/@topolo/sdk/dist/node/credential-store.js
+// ../../../../../TopoloWork2/.worktrees/cli-postinstall-message/packages/topolo-cli/node_modules/@topolo/sdk/dist/node/credential-store.js
 import { mkdir, readFile, writeFile, chmod, rm, stat } from "fs/promises";
 import { existsSync } from "fs";
 import { homedir, platform } from "os";
@@ -4643,8 +5107,20 @@ async function readCodexRegistrations(homeDir) {
   if (!existsSync2(path)) return [];
   const registrations = /* @__PURE__ */ new Map();
   let section;
+  let pending;
   for (const rawLine of (await readFile3(path, "utf8")).split(/\r?\n/)) {
-    const line = rawLine.trim();
+    const line = stripTomlComment(rawLine).trim();
+    if (pending) {
+      if (line.startsWith("[")) {
+        throw new Error(`Cannot read unsupported MCP value in Codex configuration at ${path}.`);
+      }
+      pending.value = `${pending.value} ${line}`;
+      if (isTomlValueComplete(pending.value)) {
+        applyCodexAssignment(path, section, pending, registrations);
+        pending = void 0;
+      }
+      continue;
+    }
     const heading = line.match(/^\[mcp_servers\.([A-Za-z0-9_-]+)(\.env)?\]$/);
     if (heading) {
       section = { name: heading[1], env: Boolean(heading[2]) };
@@ -4660,20 +5136,120 @@ async function readCodexRegistrations(homeDir) {
     if (!section || !isPublicRegistrationName(section.name) || !line || line.startsWith("#")) continue;
     const assignment = line.match(/^([A-Za-z0-9_]+)\s*=\s*(.+)$/);
     if (!assignment) continue;
-    const registration = registrations.get(section.name);
-    try {
-      const value = JSON.parse(assignment[2]);
-      if (section.env && typeof value === "string") registration.env[assignment[1]] = value;
-      if (!section.env && assignment[1] === "command" && typeof value === "string") registration.command = value;
-      if (!section.env && assignment[1] === "args" && Array.isArray(value) && value.every((item) => typeof item === "string")) {
-        registration.args = value;
-      }
-    } catch {
-      throw new Error(`Cannot read unsupported MCP value in Codex configuration at ${path}.`);
+    if (!section.env && assignment[1] !== "command" && assignment[1] !== "args") continue;
+    pending = { key: assignment[1], value: assignment[2] };
+    if (isTomlValueComplete(pending.value)) {
+      applyCodexAssignment(path, section, pending, registrations);
+      pending = void 0;
     }
   }
+  if (pending) throw new Error(`Cannot read unsupported MCP value in Codex configuration at ${path}.`);
   return [...registrations.values()].filter((registration) => registration.command);
 }
+function applyCodexAssignment(path, section, assignment, registrations) {
+  const registration = registrations.get(section.name);
+  let value;
+  try {
+    value = parseTomlValue(assignment.value);
+  } catch {
+    throw new Error(`Cannot read unsupported MCP value in Codex configuration at ${path}.`);
+  }
+  if (section.env && typeof value === "string") registration.env[assignment.key] = value;
+  if (!section.env && assignment.key === "command" && typeof value === "string") registration.command = value;
+  if (!section.env && assignment.key === "args" && Array.isArray(value) && value.every((item) => typeof item === "string")) {
+    registration.args = value;
+  }
+}
+function stripTomlComment(line) {
+  let quote;
+  let escaped = false;
+  for (let index = 0; index < line.length; index += 1) {
+    const character = line[index];
+    if (quote === '"') {
+      if (escaped) escaped = false;
+      else if (character === "\\") escaped = true;
+      else if (character === '"') quote = void 0;
+      continue;
+    }
+    if (quote === "'") {
+      if (character === "'" && line[index + 1] === "'") index += 1;
+      else if (character === "'") quote = void 0;
+      continue;
+    }
+    if (character === '"' || character === "'") quote = character;
+    else if (character === "#") return line.slice(0, index);
+  }
+  return line;
+}
+function isTomlValueComplete(value) {
+  let quote;
+  let escaped = false;
+  let arrayDepth = 0;
+  for (let index = 0; index < value.length; index += 1) {
+    const character = value[index];
+    if (quote === '"') {
+      if (escaped) escaped = false;
+      else if (character === "\\") escaped = true;
+      else if (character === '"') quote = void 0;
+      continue;
+    }
+    if (quote === "'") {
+      if (character === "'" && value[index + 1] === "'") index += 1;
+      else if (character === "'") quote = void 0;
+      continue;
+    }
+    if (character === '"' || character === "'") quote = character;
+    else if (character === "[") arrayDepth += 1;
+    else if (character === "]") arrayDepth -= 1;
+  }
+  return !quote && arrayDepth === 0;
+}
+function parseTomlValue(rawValue) {
+  const value = rawValue.trim();
+  try {
+    return JSON.parse(value);
+  } catch {
+  }
+  if (value.startsWith("'") && value.endsWith("'")) return value.slice(1, -1).replace(/''/g, "'");
+  if (value.startsWith("[") && value.endsWith("]")) {
+    const body = value.slice(1, -1).trim();
+    if (!body) return [];
+    return splitTomlArray(body).map((item) => parseTomlValue(item));
+  }
+  throw new Error("Unsupported TOML value");
+}
+function splitTomlArray(value) {
+  const items = [];
+  let start = 0;
+  let quote;
+  let escaped = false;
+  let arrayDepth = 0;
+  for (let index = 0; index < value.length; index += 1) {
+    const character = value[index];
+    if (quote === '"') {
+      if (escaped) escaped = false;
+      else if (character === "\\") escaped = true;
+      else if (character === '"') quote = void 0;
+      continue;
+    }
+    if (quote === "'") {
+      if (character === "'" && value[index + 1] === "'") index += 1;
+      else if (character === "'") quote = void 0;
+      continue;
+    }
+    if (character === '"' || character === "'") quote = character;
+    else if (character === "[") arrayDepth += 1;
+    else if (character === "]") arrayDepth -= 1;
+    else if (character === "," && arrayDepth === 0) {
+      const item = value.slice(start, index).trim();
+      if (item) items.push(item);
+      start = index + 1;
+    }
+  }
+  const last = value.slice(start).trim();
+  if (last) items.push(last);
+  return items;
+}
 function normalizeRegistration(name, value) {
   if (!value || typeof value !== "object" || Array.isArray(value)) return [];
   const candidate = value;

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@topolo/cli",
-  "version": "0.9.7",
-  "topoloPublishedVersion": "0.9.7",
+  "version": "0.9.9",
+  "topoloPublishedVersion": "0.9.9",
   "description": "Public command-line interface for Topolo customer organizations, developers, and agents.",
   "license": "UNLICENSED",
   "author": "Topolo",
@@ -12,9 +12,11 @@
   },
   "files": [
     "dist",
-    "skills"
+    "skills",
+    "postinstall.mjs"
   ],
   "scripts": {
+    "postinstall": "node postinstall.mjs",
     "build": "tsup",
     "dev": "tsup --watch",
     "typecheck": "tsc --noEmit",
@@ -26,7 +28,7 @@
   "dependencies": {
     "@modelcontextprotocol/sdk": "^1.0.0",
     "@topolo/mcp": "0.11.12",
-    "@topolo/sdk": "0.14.2",
+    "@topolo/sdk": "0.14.4",
     "commander": "^12.1.0"
   },
   "devDependencies": {

package/postinstall.mjs

@@ -0,0 +1,14 @@
+const message = [
+  'Topolo CLI installed successfully.',
+  '',
+  'AI assistant: continue automatically with these setup actions:',
+  '  1. Run: topolo setup',
+  '  2. Authenticate: topolo auth login',
+  '  3. Inspect contexts: topolo context ls --json',
+  '  4. Verify: topolo doctor',
+  '',
+  'If multiple contexts are listed, use the exact intended context returned by the CLI; do not guess organization IDs.',
+  'Only pause for the browser sign-in or an operating-system permission prompt.',
+].join('\n');
+
+process.stdout.write(`${message}\n`);