@subshell-ai/plugin-oh-my-pi 0.2.2 → 0.3.0

package/dist/index.d.ts

@@ -1,4 +1,31 @@
-//#region ../../plugin-api/dist/types-DPriUYLa.d.ts
+//#region ../../plugin-api/dist/types-DPLl6DHG.d.ts
+//#region src/previews.d.ts
+/**
+ * How a harness reports loopback ports its own tooling started, for the
+ * preview picker.
+ *
+ * Port discovery attributes sockets by walking the pane's process tree. A
+ * harness that brokers its tool shells through a shared daemon (oh-my-pi
+ * does) leaves that tree, so a server its tools start is reachable but
+ * invisible. A plugin that declares the `previews` capability ships a
+ * reporter the control plane can list those ports from.
+ *
+ * The report carries ports only, never a host: the node dials loopback, so a
+ * report cannot point the proxy at another machine.
+ */
+type HarnessPreviewReporting = "extension" | "hooks";
+/**
+ * What a harness declares about its preview reporting. The rules mirror
+ * {@link HarnessSubagentSupport}: `reporting` is checked against the union at
+ * load, and `setup` is the copy the preset editor shows when a human act is
+ * needed before reports start.
+ */
+interface HarnessPreviews {
+  /** How reports reach the plane: a per-launch extension, or harness lifecycle hooks. */
+  reporting: HarnessPreviewReporting;
+  /** One-time human action required for reporting to work, if any. */
+  setup?: string;
+}
 /** How the plugin learns about children: harness lifecycle hooks, or a loaded extension. */
 type HarnessSubagentDiscovery = "hooks" | "extension";
 /** Whether the sidebar can move the parent's own view to a child, or the harness keeps that in-app. */
@@ -43,7 +70,7 @@ type PluginType = "agent-harness" | "terminal" | "network";
  * and a network plugin claiming `resume` are both refused at load, for the
  * same reason a claimed-but-unimplemented capability is.
  */
-type PluginCapability = "mcp" | "resume" | "attention" | "subagents" | "publish" | "supervise" | "guard" | "settings";
+type PluginCapability = "mcp" | "resume" | "attention" | "subagents" | "previews" | "publish" | "supervise" | "guard" | "settings";
 /** A harness preset as defined by the user (decoded JSON blobs). */
 interface PresetDefinition {
   /** Human-friendly preset name */
@@ -380,6 +407,13 @@ interface PluginSecrets {
 interface SubshellPlugin {
   /** Native child-agent reporting and optional in-place navigation. */
   subagents?: HarnessSubagentSupport;
+  /**
+   * Native preview-port reporting: the harness tells the plane which loopback
+   * ports its tooling serves, so the picker lists servers discovery cannot
+   * attribute to the pane's process tree. Declare the `previews` capability
+   * with it.
+   */
+  previews?: HarnessPreviews;
   /** Builds the argv (no shell) used to launch a subshell. */
   buildCommand(input: BuildCommandInput): string[];
   /** Validates a preset definition before saving. */

package/dist/index.js

@@ -1,4 +1,4 @@
-//#region ../../plugin-api/dist/manifest-Cdy9tSLl.js
+//#region ../../plugin-api/dist/manifest-DgWWfiH-.js
 /** Every {@link PluginType}, for anything that has to iterate or validate them. */
 const PLUGIN_TYPES = [
 	"agent-harness",
@@ -287,6 +287,158 @@ function validateGenericPreset(preset) {
 	};
 }
 //#endregion
+//#region src/previews.ts
+/**
+* omp brokers tool shells through its own daemon, so servers those tools
+* start live outside the pane's process tree and port discovery cannot see
+* them. This extension watches tool results for loopback URLs and reports
+* the ports to the control plane, where the preview picker lists them.
+*
+* It deliberately reports what the output says, not a scan: a tool result
+* from something that executes (bash or a custom tool) is the harness's own
+* evidence that it started something, so file-reading tools are skipped. The
+* report is port-only (the node dials loopback), bounded, and coalesced. A
+* port the harness has not mentioned for ten minutes stops being refreshed,
+* and the server's TTL retires it. A pane without the identity environment
+* has no endpoint and stays quiet.
+*/
+const PREVIEW_BRIDGE = `
+export default function (pi) {
+  const REPORT_DELAY_MS = 750;
+  const HEARTBEAT_MS = 60_000;
+  const FRESH_MS = 10 * 60_000;
+  const MAX_PORTS = 32;
+  const MAX_TITLE = 120;
+  const MAX_SCAN = 64 * 1024;
+  const SKIP_TOOLS = { read: true, edit: true, write: true, grep: true, glob: true };
+  const URL_RE = /(?:https?:\\/\\/)?(?:localhost|127\\.0\\.0\\.1|0\\.0\\.0\\.0|\\[::1\\]):(\\d{1,5})(?!\\d)/gi;
+
+  const ports = new Map();
+  let timer = null;
+  let heartbeat = null;
+  let reporting = false;
+  let queued = false;
+  let warned = false;
+  let disabled = false;
+  const prune = now => {
+    for (const [port, entry] of ports) {
+      if (now - entry.seenAt > FRESH_MS) ports.delete(port);
+    }
+    if (ports.size === 0 && heartbeat !== null) {
+      clearInterval(heartbeat);
+      heartbeat = null;
+    }
+  };
+  const remember = (port, title) => {
+    if (!Number.isInteger(port) || port < 1 || port > 65535) return;
+    const now = Date.now();
+    prune(now);
+    const previous = ports.get(port);
+    if (previous) {
+      previous.seenAt = now;
+      if (title && !previous.title) previous.title = title;
+    } else {
+      if (ports.size >= MAX_PORTS) return;
+      ports.set(port, { title, seenAt: now });
+    }
+    if (heartbeat === null) heartbeat = setInterval(beat, HEARTBEAT_MS);
+    schedule();
+  };
+
+  const scan = text => {
+    const bounded = text.slice(0, MAX_SCAN);
+    URL_RE.lastIndex = 0;
+    let match;
+    while ((match = URL_RE.exec(bounded))) {
+      const port = Number(match[1]);
+      const start = bounded.lastIndexOf('\\n', match.index) + 1;
+      const end = bounded.indexOf('\\n', match.index);
+      const line = bounded.slice(start, end === -1 ? bounded.length : end).trim();
+      remember(port, line ? line.slice(0, MAX_TITLE) : undefined);
+    }
+  };
+
+  const report = async () => {
+    if (disabled || ports.size === 0) return;
+    if (reporting) {
+      queued = true;
+      return;
+    }
+    const base = process.env.SUBSHELL_BASE_URL;
+    const token = process.env.SUBSHELL_API_KEY;
+    const id = process.env.SUBSHELL_ID;
+    if (!base || !token || !id) {
+      if (!warned) {
+        warned = true;
+        pi.logger?.debug?.('subshell preview report skipped: the pane identity environment is missing');
+      }
+      return;
+    }
+    prune(Date.now());
+    if (ports.size === 0) return;
+    reporting = true;
+    try {
+      const response = await fetch(base + '/api/subshells/' + encodeURIComponent(id) + '/views/report', {
+        method: 'POST',
+        headers: { authorization: 'Bearer ' + token, 'content-type': 'application/json' },
+        body: JSON.stringify({
+          ports: [...ports.entries()].map(([port, entry]) => ({
+            port,
+            ...(entry.title ? { title: entry.title } : {}),
+          })),
+        }),
+        signal: AbortSignal.timeout(2000),
+      });
+      if (response.status === 404 || response.status === 401) {
+        // The server either predates the route or no longer accepts this
+        // pane's key. Retrying every heartbeat cannot fix either, so stop
+        // until a restart hands the extension a new process.
+        disabled = true;
+        if (heartbeat !== null) {
+          clearInterval(heartbeat);
+          heartbeat = null;
+        }
+      }
+      if (!response.ok && !warned) {
+        warned = true;
+        pi.logger?.debug?.('subshell preview report failed', { status: response.status });
+      }
+    } catch {
+      // A failed report is not fatal: the next tool result reports again.
+    } finally {
+      reporting = false;
+      if (queued) {
+        queued = false;
+        void report();
+      }
+    }
+  };
+
+  const schedule = () => {
+    if (timer !== null) return;
+    timer = setTimeout(() => {
+      timer = null;
+      void report();
+    }, REPORT_DELAY_MS);
+  };
+
+  const beat = () => {
+    prune(Date.now());
+    if (ports.size > 0) void report();
+  };
+
+  pi.on('tool_result', event => {
+    if (!event || event.isError) return;
+    const name = typeof event.toolName === 'string' ? event.toolName : '';
+    if (SKIP_TOOLS[name] === true) return;
+    const content = Array.isArray(event.content) ? event.content : [];
+    for (const block of content) {
+      if (block && block.type === 'text' && typeof block.text === 'string') scan(block.text);
+    }
+  });
+}
+`;
+//#endregion
 //#region src/subagents.ts
 /**
 * omp's session event bus already carries the roster the task tool is running:
@@ -486,7 +638,7 @@ export default function (pi) {
 const parsed = parseManifest({
 	name: "@subshell-ai/plugin-oh-my-pi",
 	description: "Oh My Pi harness plugin for Subshell",
-	version: "0.2.2",
+	version: "0.3.0",
 	license: "Apache-2.0",
 	type: "module",
 	main: "dist/index.js",
@@ -598,6 +750,163 @@ const SETTINGS = [
 */
 const TITLE_PREFIX = /^π(?:$|\s+(?:[>!:]|[⠁-⣿]|[◔◑◕○●]|[-\\/|])|:(?=\s|$))\s*/u;
 /**
+* Loads that provider from the environment. The source is fixed: it names the
+* variable and never interpolates its value, so no preset data (and no
+* credential) is written to a node. A launch without the variable loads
+* nothing, which keeps the module inert for every other omp preset.
+*
+* The value is preset-controlled, so malformed or incomplete JSON leaves the
+* module inert too. It must match what `model-cli omp` generates and nothing
+* else: the provider keeps model-cli's namespace, so a preset cannot override
+* a built-in provider; the apiKey is the env-var name rather than a literal
+* secret; and no field may carry omp's `!command` config syntax, which would
+* run shell commands as the pane user. Registration is queued outside the
+* extension factory's error guard, so a value omp would reject there would
+* take the pane down at startup instead of warning. One debug line names the
+* problem, never the value.
+*
+* A preset built from `model-cli omp` used to name its provider by an
+* `--extension` path in the generating host's cache, so it only worked on
+* machines where model-cli had run. This module rides the per-launch
+* extension directory the host already ships to every node instead.
+*/
+const MODEL_CLI_PROVIDER_SHIM = `export default function(pi) {
+  const raw = process.env.MODEL_CLI_OMP_CONFIG;
+  if (!raw) return;
+  let config;
+  try {
+    config = JSON.parse(raw);
+  } catch {
+    pi.logger?.debug?.("model-cli provider config ignored: MODEL_CLI_OMP_CONFIG is not JSON");
+    return;
+  }
+
+  const CONNECTION_KEYS = ["baseUrl", "api", "apiKey", "models"];
+  const MODEL_KEYS = [
+    "id",
+    "name",
+    "contextWindow",
+    "maxTokens",
+    "reasoning",
+    "input",
+    "cost",
+    "compat",
+    "thinking",
+  ];
+  const COST_KEYS = ["input", "output", "cacheRead", "cacheWrite"];
+  const COMPAT_KEYS = [
+    "maxTokensField",
+    "reasoningContentField",
+    "replayReasoningContent",
+    "requiresReasoningContentForAllAssistantTurns",
+    "supportsDeveloperRole",
+    "supportsStore",
+    "supportsStrictMode",
+    "thinkingFormat",
+  ];
+  const THINKING_KEYS = ["mode", "efforts", "effortMap"];
+
+  const isObject = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+  const only = (value, keys) => Object.keys(value).every((key) => keys.includes(key));
+  const text = (value) => typeof value === "string" && value !== "";
+  const amount = (value) => typeof value === "number" && Number.isFinite(value) && value >= 0;
+  const positive = (value) => amount(value) && value > 0;
+  const command = (value) => {
+    if (typeof value === "string") return value.startsWith("!");
+    if (Array.isArray(value)) return value.some(command);
+    if (isObject(value)) return Object.values(value).some(command);
+    return false;
+  };
+  const cost = (value) => isObject(value) && only(value, COST_KEYS) && Object.values(value).every(amount);
+  const compat = (value) =>
+    isObject(value) &&
+    only(value, COMPAT_KEYS) &&
+    Object.values(value).every((item) => typeof item === "string" || typeof item === "boolean");
+  const thinking = (value) =>
+    isObject(value) &&
+    only(value, THINKING_KEYS) &&
+    (value.mode === "anthropic-adaptive" || value.mode === "effort") &&
+    Array.isArray(value.efforts) &&
+    value.efforts.every(text) &&
+    isObject(value.effortMap) &&
+    Object.values(value.effortMap).every(text);
+  const model = (value) =>
+    isObject(value) &&
+    only(value, MODEL_KEYS) &&
+    text(value.id) &&
+    (value.name === undefined || text(value.name)) &&
+    (value.contextWindow === undefined || positive(value.contextWindow)) &&
+    (value.maxTokens === undefined || positive(value.maxTokens)) &&
+    (value.reasoning === undefined || typeof value.reasoning === "boolean") &&
+    (value.input === undefined ||
+      (Array.isArray(value.input) && value.input.every((item) => item === "text" || item === "image"))) &&
+    (value.cost === undefined || cost(value.cost)) &&
+    (value.compat === undefined || compat(value.compat)) &&
+    (value.thinking === undefined || thinking(value.thinking));
+
+  const connection = config?.connection;
+  const models = connection?.models;
+  const usable =
+    typeof config?.provider === "string" &&
+    /^model-cli-omp-(?:litellm|direct)-\\S+$/.test(config.provider) &&
+    isObject(connection) &&
+    only(connection, CONNECTION_KEYS) &&
+    typeof connection.baseUrl === "string" &&
+    /^https?:\\/\\/.+/.test(connection.baseUrl) &&
+    (connection.api === "anthropic-messages" || connection.api === "openai-completions") &&
+    connection.apiKey === "MODEL_CLI_OMP_API_KEY" &&
+    Array.isArray(models) &&
+    models.length > 0 &&
+    models.every(model) &&
+    !command(config);
+  if (!usable) {
+    pi.logger?.debug?.("model-cli provider config ignored: MODEL_CLI_OMP_CONFIG is not the model-cli shape");
+    return;
+  }
+  pi.registerProvider(config.provider, connection);
+}
+`;
+/**
+* A preset built from `model-cli omp` used to prove its provider with an
+* extension path in the generating host's cache. That file is writable by
+* anything running as the pane user and persists between launches, so the
+* provider module below is a replacement, not a companion: the legacy flag is
+* dropped when this launch writes its own module. omp accepts the path as
+* `--extension`, `--trusted-extension`, `-e` or `--hook`, so every spelling is
+* matched, and the path is normalized first because `./` and doubled
+* separators name the same file.
+*/
+const LEGACY_PROVIDER_FLAGS = [
+	"--extension",
+	"--trusted-extension",
+	"-e",
+	"--hook"
+];
+const LEGACY_PROVIDER_INLINE = [
+	"--extension=",
+	"--trusted-extension=",
+	"-e=",
+	"--hook="
+];
+function isLegacyProviderPath(value) {
+	const segments = value.trim().replace(/\\/g, "/").split("/").filter((segment) => segment !== "" && segment !== ".");
+	return /(?:^|\/)model-cli\/omp-provider\.mjs$/.test(segments.join("/"));
+}
+function withoutLegacyProviderExtension(flags) {
+	const kept = [];
+	for (let i = 0; i < flags.length; i++) {
+		const flag = flags[i];
+		if (LEGACY_PROVIDER_FLAGS.includes(flag) && isLegacyProviderPath(flags[i + 1] ?? "")) {
+			i += 1;
+			continue;
+		}
+		const inline = LEGACY_PROVIDER_INLINE.find((prefix) => flag.startsWith(prefix));
+		if (inline && isLegacyProviderPath(flag.slice(inline.length))) continue;
+		kept.push(flag);
+	}
+	return kept;
+}
+/**
 * Oh My Pi uses its own executable and native MCP discovery, independently of
 * pi. An explicit extension directory contributes mcp.json without redirecting
 * the user's config or credentials. Verified against omp 18.12.6.
@@ -612,8 +921,10 @@ const createPlugin = () => ({
 		discovery: "extension",
 		navigation: "unavailable"
 	},
+	previews: { reporting: "extension" },
 	capabilities: () => [
 		"subagents",
+		"previews",
 		"mcp",
 		"settings"
 	],
@@ -630,7 +941,7 @@ const createPlugin = () => ({
 			const value = settings[key];
 			if (typeof value === "string" && value) args.push(`--${key}`, value);
 		}
-		args.push(...preset.flags, ...extraFlags ?? []);
+		args.push(...mcp ? withoutLegacyProviderExtension(preset.flags) : preset.flags, ...extraFlags ?? []);
 		return args;
 	},
 	mcpRegistration(launch, configPath) {
@@ -646,10 +957,17 @@ const createPlugin = () => ({
 					name: "subshell-mcp",
 					private: true,
 					type: "module",
-					omp: { extensions: ["bridge.mjs", "subagents.mjs"] }
+					omp: { extensions: [
+						"bridge.mjs",
+						"subagents.mjs",
+						"previews.mjs",
+						"provider.mjs"
+					] }
 				}),
 				"bridge.mjs": "export default function () {}\n",
 				"subagents.mjs": SUBAGENT_BRIDGE,
+				"previews.mjs": PREVIEW_BRIDGE,
+				"provider.mjs": MODEL_CLI_PROVIDER_SHIM,
 				"mcp.json": fileContent
 			},
 			args: ["--extension", `${configPath}.d`]

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@subshell-ai/plugin-oh-my-pi",
   "description": "Oh My Pi harness plugin for Subshell",
-  "version": "0.2.2",
+  "version": "0.3.0",
   "license": "Apache-2.0",
   "type": "module",
   "main": "dist/index.js",