@growthub/cli 0.9.17 → 0.10.0

package/assets/worker-kits/growthub-custom-workspace-starter-v1/apps/workspace/lib/adapters/references/resolvers/local-data-model.js

@@ -0,0 +1,11 @@
+/**
+ * Local workspace-config reference options (dataModel.objects[] rows).
+ */
+
+import { resolveLocalReferenceOptions } from "@/lib/workspace-data-model";
+
+function resolveLocalWorkspaceOptions(workspaceConfig, params) {
+  return resolveLocalReferenceOptions(workspaceConfig, params);
+}
+
+export { resolveLocalWorkspaceOptions };

package/assets/worker-kits/growthub-custom-workspace-starter-v1/apps/workspace/lib/adapters/references/resolvers/source-records.js

@@ -0,0 +1,34 @@
+/**
+ * Source-record sidecar rows as reference options (growthub.source-records.json).
+ */
+
+import { readWorkspaceSourceRecords } from "@/lib/workspace-config";
+import { normalizeReferenceOption } from "@/lib/workspace-data-model";
+
+async function resolveSourceRecordReferenceOptions(sourceId, { query = "", limit = 25 } = {}) {
+  if (!sourceId || typeof sourceId !== "string") {
+    return { options: [], reason: "missing-source-id" };
+  }
+  const sidecar = await readWorkspaceSourceRecords(sourceId.trim());
+  const records = Array.isArray(sidecar?.records) ? sidecar.records : [];
+  const needle = String(query || "").trim().toLowerCase();
+  const opts = [];
+  records.forEach((rec, index) => {
+    const value = String(rec?.id ?? rec?.runId ?? `idx-${index}`).trim();
+    if (!value) return;
+    const label = String(rec?.label ?? rec?.runId ?? value).trim() || value;
+    if (needle && !`${value} ${label}`.toLowerCase().includes(needle)) return;
+    opts.push(
+      normalizeReferenceOption({
+        value,
+        label,
+        source: "source-records",
+        status: typeof rec?.status === "string" ? rec.status : undefined,
+        metadata: { ranAt: rec?.ranAt }
+      })
+    );
+  });
+  return { options: opts.filter(Boolean).slice(0, limit), reason: null };
+}
+
+export { resolveSourceRecordReferenceOptions };

package/assets/worker-kits/growthub-custom-workspace-starter-v1/apps/workspace/lib/adapters/sandboxes/adapters/README.md

@@ -2,10 +2,11 @@
 
 Drop one `.js` file per execution target here. Each file calls `registerSandboxAdapter()` once at module load.
 
-This is the thin agnostic extension point for the **`sandbox-environment` governed Data Model object**. Two default adapters ship eagerly with every workspace, loaded by `lib/adapters/sandboxes/index.js`:
+This is the thin agnostic extension point for the **`sandbox-environment` governed Data Model object**. Three default adapters ship eagerly with every workspace, loaded by `lib/adapters/sandboxes/index.js`:
 
-- **`local-process`** (`default-local-process.js`) — spawns python3 / node / bash inside an isolated `/tmp/growthub-sandbox-*` workdir with timeout + captured stdio. Use this when the row is a deterministic script.
-- **`local-agent-host`** (`default-local-agent-host.js`) — Paperclip thin local adapter. Routes the row through whichever local agent host CLI the operator has on PATH (Claude Code, Codex, Cursor, Gemini, OpenCode, Pi, Qwen, Hermes, OpenClaw Gateway). Cross-platform — works on macOS, Windows, and Linux. Slugs mirror the canonical `AGENT_ADAPTER_TYPES` enum so a row is portable to the upstream Paperclip server adapter registry without translation.
+- **`local-process`** (`../default-local-process.js`) — spawns python3 / node / bash inside an isolated `/tmp/growthub-sandbox-*` workdir with timeout + captured stdio. Use this when the row is a deterministic script.
+- **`local-agent-host`** (`../default-local-agent-host.js`) — Paperclip thin local adapter. Routes the row through whichever local agent host CLI the operator has on PATH (Claude Code, Codex, Cursor, Gemini, OpenCode, Pi, Qwen, Hermes, OpenClaw Gateway). Cross-platform — works on macOS, Windows, and Linux. Slugs mirror the canonical `AGENT_ADAPTER_TYPES` enum so a row is portable to the upstream Paperclip server adapter registry without translation.
+- **`local-intelligence`** (`../default-local-intelligence.js`) — OpenAI-compatible **JSON-only** chat-completions call to the operator's local stack (Ollama / LM Studio / vLLM / custom URL). The merged **Instructions + Command** field is the user task. Tool intents in the JSON response are **proposals only** — this adapter never executes them.
 
 Files added to this drop-zone are loaded by `adapter-loader.js` on the first sandbox-run route invocation. Use the drop-zone for hardened isolation primitives (firejail, gVisor, Docker, Fly Machines, e2b, modal.com) or for additional agent host targets the canonical catalog does not yet cover.
 
@@ -61,3 +62,4 @@ When the sandbox row’s **`runLocality`** is **`serverless`**, the sandbox-run
 2. The route mints **`growthub-sandbox-run-v1`** JSON (no secrets inline) and **POST**s using the merged registry/request shape (parity with outbound test routes).
 3. The handler translates its own queue (KV, Postgres, cron tick, etc.) into a normal JSON or text reply; the route maps that reply into **`stdout`**, optional **`stderr`**, and **`exitCode`** — same **`lastResponse`** / sidecar semantics as **local**.
 4. Drop-zone adapters labelled **`locality: "serverless"`** are **not** used for delegation today; outbound HTTP replaces them so operators wire **already-supported** integrations + infra without a second resolver graph.
+5. Rows using **`local-intelligence`** must keep **`runLocality: "local"`** — that adapter performs an outbound HTTP call to the operator's machine only; it cannot be combined with serverless delegation.

package/assets/worker-kits/growthub-custom-workspace-starter-v1/apps/workspace/lib/adapters/sandboxes/default-local-intelligence.js

@@ -0,0 +1,203 @@
+/**
+ * Sandbox adapter — governed local OpenAI-compatible inference (JSON-only).
+ *
+ * Uses the same mental model as Growthub Local Intelligence: chat-completions
+ * transport, normalized JSON envelope on stdout. Tool intents are proposals
+ * only — this adapter performs no tool execution and never resolves env secrets
+ * beyond what the sandbox-run route already placed on `request.env`.
+ */
+
+import { Buffer } from "node:buffer";
+import { registerSandboxAdapter } from "./sandbox-adapter-registry.js";
+
+const MAX_OUT = 256 * 1024;
+
+function clampStream(buffer) {
+  if (buffer.length <= MAX_OUT) return buffer.toString("utf8");
+  return `${buffer.slice(0, MAX_OUT).toString("utf8")}\n…\n[truncated]`;
+}
+
+function resolveChatCompletionsUrl(mode, explicit) {
+  const e = String(explicit || "").trim();
+  if (e && /^https?:\/\//i.test(e)) {
+    if (e.includes("/chat/completions")) return e.replace(/\/+$/, "");
+    return `${e.replace(/\/+$/, "")}/chat/completions`;
+  }
+  const m = String(mode || "ollama").toLowerCase();
+  if (m === "custom-openai-compatible") {
+    if (!e) throw new Error("localEndpoint (full chat completions URL) is required for custom-openai-compatible mode");
+    if (e.includes("/chat/completions")) return e.replace(/\/+$/, "");
+    return `${e.replace(/\/+$/, "")}/chat/completions`;
+  }
+  const ollamaBase = (process.env.OLLAMA_BASE_URL || "http://127.0.0.1:11434/v1").replace(/\/$/, "");
+  if (m === "lmstudio") {
+    const b = (process.env.LMSTUDIO_BASE_URL || "http://127.0.0.1:1234/v1").replace(/\/$/, "");
+    return `${b}/chat/completions`;
+  }
+  if (m === "vllm") {
+    const b = String(process.env.VLLM_BASE_URL || "").trim().replace(/\/$/, "");
+    if (!b) throw new Error("VLLM_BASE_URL is required for vllm intelligenceAdapterMode");
+    return `${b}/chat/completions`;
+  }
+  return `${ollamaBase}/chat/completions`;
+}
+
+function buildSystemPrompt() {
+  return [
+    "You are Growthub workspace sandbox local intelligence.",
+    "Reply with a single JSON object only, matching:",
+    "{\"text\":string optional,\"json\":object optional,\"toolIntents\":[],\"warnings\":[],\"confidence\":number}",
+    "toolIntents are proposals only — never claim execution or access to secrets.",
+  ].join("\n");
+}
+
+async function run(request) {
+  const started = Date.now();
+  const box = request.intelligenceSandbox;
+  if (!box || typeof box.userIntent !== "string") {
+    return {
+      ok: false,
+      exitCode: 1,
+      durationMs: Date.now() - started,
+      stdout: "",
+      stderr: "",
+      error: "intelligenceSandbox.userIntent is required for local-intelligence adapter",
+      adapterMeta: { adapter: "local-intelligence" },
+    };
+  }
+
+  let endpoint;
+  try {
+    endpoint = resolveChatCompletionsUrl(box.intelligenceAdapterMode, box.localEndpoint);
+  } catch (err) {
+    return {
+      ok: false,
+      exitCode: 1,
+      durationMs: Date.now() - started,
+      stdout: "",
+      stderr: "",
+      error: err.message || String(err),
+      adapterMeta: { adapter: "local-intelligence" },
+    };
+  }
+
+  const model =
+    String(box.localModel || "").trim()
+    || String(process.env.NATIVE_INTELLIGENCE_LOCAL_MODEL || process.env.OLLAMA_MODEL || "").trim()
+    || "gemma3:4b";
+
+  const body = {
+    model,
+    messages: [
+      { role: "system", content: buildSystemPrompt() },
+      { role: "user", content: box.userIntent },
+    ],
+    temperature: 0.3,
+    response_format: { type: "json_object" },
+  };
+
+  const controller = new AbortController();
+  const ms = Number(request.timeoutMs) > 0 ? Math.min(Number(request.timeoutMs), 600000) : 60000;
+  const timer = setTimeout(() => controller.abort(), ms);
+
+  try {
+    const res = await fetch(endpoint, {
+      method: "POST",
+      headers: { "content-type": "application/json", accept: "application/json" },
+      body: JSON.stringify(body),
+      signal: controller.signal,
+    });
+    const buf = Buffer.from(await res.arrayBuffer());
+    const text = clampStream(buf);
+    const durationMs = Date.now() - started;
+    if (!res.ok) {
+      return {
+        ok: false,
+        exitCode: 1,
+        durationMs,
+        stdout: text,
+        stderr: "",
+        error: `local model HTTP ${res.status}`,
+        adapterMeta: { adapter: "local-intelligence", endpoint, model },
+      };
+    }
+
+    let parsed;
+    let outer;
+    try {
+      outer = JSON.parse(text);
+    } catch {
+      outer = null;
+    }
+    if (outer && Array.isArray(outer.choices) && outer.choices[0]?.message?.content) {
+      const inner = String(outer.choices[0].message.content || "").trim();
+      try {
+        parsed = JSON.parse(inner);
+      } catch {
+        parsed = { text: inner, warnings: ["model completion was not valid JSON"], toolIntents: [], confidence: 0 };
+      }
+    } else if (outer && typeof outer === "object") {
+      parsed = outer;
+    } else {
+      parsed = { text, warnings: ["invalid JSON from model"], toolIntents: [], confidence: 0 };
+    }
+
+    const envelope = {
+      version: "growthub-local-model-sandbox-v1",
+      taskId: request.runId,
+      businessObjectType: "sandbox-environment",
+      adapter: {
+        kind: "local-intelligence",
+        mode: box.intelligenceAdapterMode || "ollama",
+        modelId: model,
+        endpoint,
+      },
+      result: {
+        text: typeof parsed.text === "string" ? parsed.text : undefined,
+        json: parsed.json && typeof parsed.json === "object" ? parsed.json : undefined,
+        toolIntents: Array.isArray(parsed.toolIntents) ? parsed.toolIntents : [],
+        warnings: Array.isArray(parsed.warnings) ? parsed.warnings : [],
+        confidence: typeof parsed.confidence === "number" ? parsed.confidence : 0,
+      },
+      rawText: text,
+      latencyMs: durationMs,
+      createdAt: new Date().toISOString(),
+    };
+
+    return {
+      ok: true,
+      exitCode: 0,
+      durationMs,
+      stdout: JSON.stringify(envelope, null, 2),
+      stderr: "",
+      adapterMeta: {
+        adapter: "local-intelligence",
+        endpoint,
+        model,
+        locality: "local",
+      },
+    };
+  } catch (err) {
+    return {
+      ok: false,
+      exitCode: 1,
+      durationMs: Date.now() - started,
+      stdout: "",
+      stderr: clampStream(Buffer.from(String(err.message || err), "utf8")),
+      error: err.name === "AbortError" ? `timed out after ${ms}ms` : err.message || "fetch failed",
+      adapterMeta: { adapter: "local-intelligence", endpoint, model },
+    };
+  } finally {
+    clearTimeout(timer);
+  }
+}
+
+registerSandboxAdapter({
+  id: "local-intelligence",
+  label: "Local intelligence (OpenAI-compatible)",
+  description:
+    "Calls your local Ollama / LM Studio / vLLM Chat Completions endpoint with JSON-only output. Tool intents are proposals — not executed here.",
+  locality: "local",
+  supportedRuntimes: [],
+  run,
+});

package/assets/worker-kits/growthub-custom-workspace-starter-v1/apps/workspace/lib/adapters/sandboxes/index.js

@@ -9,6 +9,7 @@
 
 import "./default-local-process.js";
 import "./default-local-agent-host.js";
+import "./default-local-intelligence.js";
 import { loadAllSandboxAdapters } from "./adapter-loader.js";
 
 let baseLoaded = true; // default-local-process registered via static import

package/assets/worker-kits/growthub-custom-workspace-starter-v1/apps/workspace/lib/data-model/field-contracts.js

@@ -0,0 +1,81 @@
+/**
+ * Client-safe field contracts for governed Data Model rows.
+ * Maps objectType + field → editor kind and static hints (no secrets).
+ */
+
+const TRUSTED_STATUSES = ["connected", "approved", "ok", "success"];
+
+const SANDBOX_ENVIRONMENT_FIELDS = {
+  runLocality: {
+    editor: "segmented-toggle",
+    options: ["local", "serverless"]
+  },
+  networkAllow: { editor: "boolean-toggle" },
+  lifecycleStatus: {
+    editor: "select",
+    options: ["draft", "live"]
+  },
+  runtime: {
+    editor: "select",
+    options: ["python", "node", "bash"]
+  },
+  schedulerRegistryId: {
+    editor: "reference",
+    targetObjectType: "api-registry",
+    valueField: "integrationId",
+    statusAllowlist: TRUSTED_STATUSES
+  },
+  envRefs: { editor: "env-ref-multiselect" },
+  lastResponse: { editor: "json-preview", readonly: true },
+  lastRunId: { editor: "readonly-text" },
+  lastSourceId: { editor: "readonly-text" },
+  resolverTemplateId: { editor: "readonly-text" },
+  connectorKind: { editor: "readonly-text" },
+  executionLane: { editor: "readonly-text" }
+};
+
+const API_REGISTRY_FIELDS = {
+  method: {
+    editor: "select",
+    options: ["GET", "POST", "PUT", "PATCH", "DELETE"]
+  },
+  status: { editor: "status-pill" },
+  lastResponse: { editor: "json-preview", readonly: true },
+  connectorKind: { editor: "text" },
+  resolverTemplateId: { editor: "text" },
+  schemaVersion: { editor: "text" },
+  capabilities: { editor: "text" },
+  executionLane: { editor: "text" }
+};
+
+const DATA_SOURCE_FIELDS = {
+  registryId: {
+    editor: "reference",
+    targetObjectType: "api-registry",
+    valueField: "integrationId",
+    statusAllowlist: null
+  },
+  status: { editor: "status-pill" },
+  lastResponse: { editor: "json-preview", readonly: true },
+  sourceStorage: {
+    editor: "select",
+    options: ["", "workspace-source-records"]
+  },
+  entityType: { editor: "text" },
+  sourceId: { editor: "text" },
+  resolverTemplateId: { editor: "text" }
+};
+
+const BY_OBJECT_TYPE = {
+  "sandbox-environment": SANDBOX_ENVIRONMENT_FIELDS,
+  "api-registry": API_REGISTRY_FIELDS,
+  "data-source": DATA_SOURCE_FIELDS
+};
+
+function getFieldContract(objectType, fieldName) {
+  const table = BY_OBJECT_TYPE[objectType];
+  if (!table || !fieldName) return null;
+  return table[fieldName] || null;
+}
+
+export { TRUSTED_STATUSES, getFieldContract, BY_OBJECT_TYPE };

package/assets/worker-kits/growthub-custom-workspace-starter-v1/apps/workspace/lib/data-model/reference-option-schema.js

@@ -0,0 +1,59 @@
+/**
+ * Reference option wire shape for POST /api/workspace/reference-options.
+ * Kept as plain validation (no runtime authority).
+ */
+
+function isPlainObject(value) {
+  return Boolean(value) && typeof value === "object" && !Array.isArray(value);
+}
+
+/**
+ * @typedef {Object} ReferenceOption
+ * @property {string} value
+ * @property {string} label
+ * @property {string} [secondaryLabel]
+ * @property {"workspace-config"|"source-records"|"resolver"} source
+ * @property {string} [objectType]
+ * @property {string} [provider]
+ * @property {string} [status]
+ * @property {Record<string, unknown>} [metadata]
+ */
+
+function validateReferenceOptionsRequest(body) {
+  const errors = [];
+  if (!body || typeof body !== "object" || Array.isArray(body)) {
+    errors.push("body must be a plain object");
+    return { ok: false, errors, value: null };
+  }
+  const objectId = typeof body.objectId === "string" ? body.objectId.trim() : "";
+  const field = typeof body.field === "string" ? body.field.trim() : "";
+  if (!objectId) errors.push("objectId must be a non-empty string");
+  if (!field) errors.push("field must be a non-empty string");
+  const query = typeof body.query === "string" ? body.query : "";
+  const cursor = body.cursor === null || body.cursor === undefined || body.cursor === ""
+    ? null
+    : String(body.cursor);
+  let limit = 25;
+  if (body.limit !== undefined) {
+    const limitRaw = Number(body.limit);
+    if (!Number.isFinite(limitRaw) || limitRaw < 1) {
+      errors.push("limit must be a positive number");
+    } else {
+      limit = Math.min(100, Math.max(1, limitRaw));
+    }
+  }
+  const context = isPlainObject(body.context) ? body.context : {};
+  if (body.context !== undefined && !isPlainObject(body.context)) {
+    errors.push("context must be a plain object when present");
+  }
+  if (!errors.length) {
+    return {
+      ok: true,
+      errors: [],
+      value: { objectId, field, query, cursor, limit, context }
+    };
+  }
+  return { ok: false, errors, value: null };
+}
+
+export { validateReferenceOptionsRequest };

package/assets/worker-kits/growthub-custom-workspace-starter-v1/apps/workspace/lib/data-model/reference-options.js

@@ -0,0 +1,29 @@
+/**
+ * Client helpers for reference option loading (browser-safe).
+ */
+
+const REFERENCE_OPTION_SOURCES = ["workspace-config", "source-records", "resolver"];
+
+async function fetchReferenceOptions({
+  objectId,
+  field,
+  query = "",
+  cursor = null,
+  limit = 25,
+  context = {}
+} = {}) {
+  const res = await fetch("/api/workspace/reference-options", {
+    method: "POST",
+    headers: { "content-type": "application/json" },
+    body: JSON.stringify({ objectId, field, query, cursor, limit, context })
+  });
+  const payload = await res.json();
+  if (!res.ok) {
+    const err = new Error(payload.error || "reference-options failed");
+    err.payload = payload;
+    throw err;
+  }
+  return payload;
+}
+
+export { REFERENCE_OPTION_SOURCES, fetchReferenceOptions };