opensteer 0.8.3 → 0.8.4

package/dist/cli/bin.js

@@ -1,12 +1,75 @@
 #!/usr/bin/env node
-import { assertExecutionModeSupportsEngine, createOpensteerSemanticRuntime, OpensteerBrowserManager, dispatchSemanticOperation, resolveOpensteerEngineName, discoverLocalCdpBrowsers, inspectCdpEndpoint, resolveFilesystemWorkspacePath, hasPersistedCloudSession, resolveOpensteerExecutionMode } from '../chunk-JK4NMMM2.js';
+import { assertProviderSupportsEngine, createOpensteerSemanticRuntime, OpensteerBrowserManager, dispatchSemanticOperation, pathExists, resolveOpensteerEngineName, normalizeOpensteerProviderKind, discoverLocalCdpBrowsers, inspectCdpEndpoint, resolveOpensteerRuntimeConfig, resolveOpensteerProvider, resolveFilesystemWorkspacePath, readPersistedLocalBrowserSessionRecord, readPersistedCloudSessionRecord, OpensteerCloudClient, isProcessRunning } from '../chunk-C7GWMSTV.js';
 import process2 from 'process';
+import { readFile } from 'fs/promises';
+import path2 from 'path';
 import { spawn } from 'child_process';
 import { existsSync } from 'fs';
-import path from 'path';
 import { createRequire } from 'module';
 import { fileURLToPath } from 'url';
 
+var ENV_FILENAMES = [".env", ".env.local"];
+async function loadCliEnvironment(cwd) {
+  const protectedKeys = new Set(Object.keys(process.env));
+  const directories = collectDirectories(cwd);
+  for (const directory of directories) {
+    for (const filename of ENV_FILENAMES) {
+      const filePath = path2.join(directory, filename);
+      if (!await pathExists(filePath)) {
+        continue;
+      }
+      const parsed = parseEnvFile(await readFile(filePath, "utf8"));
+      for (const [key, value] of Object.entries(parsed)) {
+        if (protectedKeys.has(key)) {
+          continue;
+        }
+        process.env[key] = value;
+      }
+    }
+  }
+}
+function collectDirectories(cwd) {
+  const directories = [];
+  let current = path2.resolve(cwd);
+  for (; ; ) {
+    directories.unshift(current);
+    const parent = path2.dirname(current);
+    if (parent === current) {
+      return directories;
+    }
+    current = parent;
+  }
+}
+function parseEnvFile(contents) {
+  const parsed = {};
+  for (const rawLine of contents.split(/\r?\n/u)) {
+    const trimmed = rawLine.trim();
+    if (!trimmed || trimmed.startsWith("#")) {
+      continue;
+    }
+    const line = trimmed.startsWith("export ") ? trimmed.slice("export ".length) : trimmed;
+    const separatorIndex = line.indexOf("=");
+    if (separatorIndex <= 0) {
+      continue;
+    }
+    const key = line.slice(0, separatorIndex).trim();
+    if (!/^[A-Za-z_][A-Za-z0-9_]*$/u.test(key)) {
+      continue;
+    }
+    const rawValue = line.slice(separatorIndex + 1).trim();
+    parsed[key] = parseEnvValue(rawValue);
+  }
+  return parsed;
+}
+function parseEnvValue(rawValue) {
+  if (rawValue.length >= 2 && rawValue.startsWith('"') && rawValue.endsWith('"')) {
+    return rawValue.slice(1, -1).replace(/\\n/g, "\n").replace(/\\r/g, "\r").replace(/\\t/g, "	").replace(/\\"/g, '"');
+  }
+  if (rawValue.length >= 2 && rawValue.startsWith("'") && rawValue.endsWith("'")) {
+    return rawValue.slice(1, -1);
+  }
+  return rawValue.replace(/\s+#.*$/u, "").trimEnd();
+}
 function createOpensteerSkillsInvocation(input) {
   const cliArgs = ["add", input.skillSourcePath];
   if (input.options.all === true) {
@@ -40,22 +103,22 @@ function createOpensteerSkillsInvocation(input) {
 function resolveOpensteerSkillsCliPath() {
   const require2 = createRequire(import.meta.url);
   const skillsPackagePath = require2.resolve("skills/package.json");
-  const skillsPackageDir = path.dirname(skillsPackagePath);
-  const cliPath = path.join(skillsPackageDir, "bin", "cli.mjs");
+  const skillsPackageDir = path2.dirname(skillsPackagePath);
+  const cliPath = path2.join(skillsPackageDir, "bin", "cli.mjs");
   if (!existsSync(cliPath)) {
     throw new Error(`skills CLI entrypoint was not found at "${cliPath}".`);
   }
   return cliPath;
 }
 function resolveOpensteerSkillSourcePath() {
-  let ancestor = path.dirname(fileURLToPath(import.meta.url));
+  let ancestor = path2.dirname(fileURLToPath(import.meta.url));
   for (let index = 0; index < 6; index += 1) {
-    const candidate = path.join(ancestor, "skills");
-    const skillManifest = path.join(candidate, "opensteer", "SKILL.md");
+    const candidate = path2.join(ancestor, "skills");
+    const skillManifest = path2.join(candidate, "opensteer", "SKILL.md");
     if (existsSync(skillManifest)) {
       return candidate;
     }
-    ancestor = path.resolve(ancestor, "..");
+    ancestor = path2.resolve(ancestor, "..");
   }
   throw new Error("Unable to find the packaged Opensteer skill source directory.");
 }
@@ -97,6 +160,161 @@ function resolveSelectedSkills(options) {
   }
   return ["opensteer"];
 }
+async function collectOpensteerStatus(input) {
+  const output = {
+    provider: {
+      current: input.provider.kind,
+      source: mapProviderSource(input.provider.source),
+      ...input.cloudConfig === void 0 ? {} : { cloudBaseUrl: input.cloudConfig.baseUrl }
+    },
+    ...input.workspace === void 0 ? {} : { workspace: input.workspace }
+  };
+  if (input.workspace === void 0) {
+    return output;
+  }
+  const rootPath = resolveFilesystemWorkspacePath({
+    rootDir: input.rootDir,
+    workspace: input.workspace
+  });
+  const localRecord = await readWorkspaceLocalRecord(rootPath);
+  const cloudRecord = await readWorkspaceCloudRecord(rootPath);
+  return {
+    ...output,
+    rootPath,
+    lanes: {
+      local: describeLocalLane(localRecord, input.provider.kind === "local"),
+      cloud: await describeCloudLane({
+        record: cloudRecord,
+        current: input.provider.kind === "cloud",
+        cloudConfig: input.cloudConfig
+      })
+    }
+  };
+}
+function renderOpensteerStatus(status) {
+  const lines = [
+    "Provider resolution",
+    `  current: ${status.provider.current}`,
+    `  source: ${status.provider.source}`
+  ];
+  if (status.provider.cloudBaseUrl !== void 0) {
+    lines.push(`  control api: ${status.provider.cloudBaseUrl}`);
+  }
+  if (status.workspace !== void 0) {
+    lines.push(`  workspace: ${status.workspace}`);
+  }
+  if (status.lanes === void 0) {
+    return `${lines.join("\n")}
+`;
+  }
+  lines.push("", "Live sessions");
+  for (const lane of [status.lanes.local, status.lanes.cloud]) {
+    lines.push(
+      formatLaneRow({
+        marker: lane.current ? "*" : " ",
+        provider: lane.provider,
+        status: lane.status,
+        summary: lane.summary ?? "none",
+        detail: lane.detail
+      })
+    );
+  }
+  return `${lines.join("\n")}
+`;
+}
+async function readWorkspaceLocalRecord(rootPath) {
+  if (!await pathExists(rootPath)) {
+    return void 0;
+  }
+  return readPersistedLocalBrowserSessionRecord(rootPath);
+}
+async function readWorkspaceCloudRecord(rootPath) {
+  if (!await pathExists(rootPath)) {
+    return void 0;
+  }
+  return readPersistedCloudSessionRecord(rootPath);
+}
+function describeLocalLane(record, current) {
+  if (record === void 0 || !isProcessRunning(record.pid)) {
+    return {
+      provider: "local",
+      status: "idle",
+      current,
+      summary: "none"
+    };
+  }
+  const browser = record.executablePath ? path2.basename(record.executablePath).replace(/\.[A-Za-z0-9]+$/u, "") : void 0;
+  return {
+    provider: "local",
+    status: "active",
+    current,
+    summary: `PID ${String(record.pid)}`,
+    detail: browser ?? record.engine,
+    pid: record.pid,
+    engine: record.engine,
+    ...browser === void 0 ? {} : { browser }
+  };
+}
+async function describeCloudLane(input) {
+  if (input.record === void 0) {
+    return {
+      provider: "cloud",
+      status: "idle",
+      current: input.current,
+      summary: "none"
+    };
+  }
+  const base = {
+    provider: "cloud",
+    status: "connected",
+    current: input.current,
+    summary: input.record.sessionId,
+    detail: input.record.baseUrl,
+    sessionId: input.record.sessionId,
+    baseUrl: input.record.baseUrl
+  };
+  if (input.cloudConfig === void 0) {
+    return base;
+  }
+  try {
+    const client = new OpensteerCloudClient(input.cloudConfig);
+    const session = await client.getSession(input.record.sessionId);
+    if (session.status === "closed") {
+      return {
+        ...base,
+        status: "closed",
+        ...session.region ?? session.runtimeRegion ? { region: session.region ?? session.runtimeRegion } : {}
+      };
+    }
+    if (session.status === "failed") {
+      return {
+        ...base,
+        status: "stale"
+      };
+    }
+    return {
+      ...base,
+      ...session.region ?? session.runtimeRegion ? { region: session.region ?? session.runtimeRegion } : {}
+    };
+  } catch {
+    return {
+      ...base,
+      status: "stale"
+    };
+  }
+}
+function mapProviderSource(source) {
+  if (source === "explicit") {
+    return "flag";
+  }
+  return source;
+}
+function formatLaneRow(input) {
+  const provider = input.provider.padEnd(7, " ");
+  const status = input.status.padEnd(9, " ");
+  const summary = input.summary.padEnd(16, " ");
+  return `${input.marker} ${provider} ${status} ${summary}${input.detail ?? ""}`.trimEnd();
+}
 
 // src/cli/bin.ts
 var OPERATION_ALIASES = /* @__PURE__ */ new Map([
@@ -153,6 +371,7 @@ var OPERATION_ALIASES = /* @__PURE__ */ new Map([
   ["close", "session.close"]
 ]);
 async function main() {
+  await loadCliEnvironment(process2.cwd());
   const parsed = parseCommandLine(process2.argv.slice(2));
   if (parsed.help || parsed.command.length === 0) {
     printHelp();
@@ -177,6 +396,10 @@ async function main() {
     }
     return;
   }
+  if (parsed.command[0] === "status") {
+    await handleStatusCommand(parsed);
+    return;
+  }
   const operation = parsed.command[0] === "run" ? parsed.rest[0] : resolveOperation(parsed.command);
   if (!operation) {
     throw new Error(`Unknown command: ${parsed.command.join(" ")}`);
@@ -184,17 +407,14 @@ async function main() {
   if (parsed.options.workspace === void 0) {
     throw new Error('Stateful commands require "--workspace <id>".');
   }
-  const mode = await resolveCliExecutionMode(parsed);
-  assertExecutionModeSupportsEngine(mode, parsed.options.engineName);
-  const cloudOptions = buildCliCloudOptions(parsed);
-  if (mode !== "cloud" && (parsed.options.cloudProfileId !== void 0 || parsed.options.cloudProfileReuseIfActive === true)) {
-    throw new Error("Cloud profile options require cloud mode.");
-  }
+  const provider = resolveCliProvider(parsed);
+  assertProviderSupportsEngine(provider.kind, parsed.options.engineName);
+  assertCloudCliOptionsMatchProvider(parsed, provider.kind);
+  const runtimeProvider = buildCliRuntimeProvider(parsed, provider.kind);
   if (operation === "session.close") {
-    if (mode === "cloud") {
+    if (provider.kind === "cloud") {
       const runtime2 = createOpensteerSemanticRuntime({
-        mode,
-        ...cloudOptions === void 0 ? {} : { cloud: cloudOptions },
+        ...runtimeProvider === void 0 ? {} : { provider: runtimeProvider },
         engine: parsed.options.engineName,
         runtimeOptions: {
           workspace: parsed.options.workspace,
@@ -223,8 +443,7 @@ async function main() {
     return;
   }
   const runtime = createOpensteerSemanticRuntime({
-    mode,
-    ...cloudOptions === void 0 ? {} : { cloud: cloudOptions },
+    ...runtimeProvider === void 0 ? {} : { provider: runtimeProvider },
     engine: parsed.options.engineName,
     runtimeOptions: {
       workspace: parsed.options.workspace,
@@ -480,10 +699,16 @@ function parseCommandLine(argv) {
   const contextJson = readJsonObject(rawOptions, "context-json");
   const inputJson = readJsonObject(rawOptions, "input-json");
   const schemaJson = readJsonObject(rawOptions, "schema-json");
-  const local = readOptionalBoolean(rawOptions, "local");
-  const cloud = readOptionalBoolean(rawOptions, "cloud");
+  const providerValue = readSingle(rawOptions, "provider");
+  const provider = providerValue === void 0 ? void 0 : normalizeOpensteerProviderKind(providerValue, "--provider");
+  const cloudBaseUrl = readSingle(rawOptions, "cloud-base-url");
+  const cloudApiKey = readSingle(rawOptions, "cloud-api-key");
   const cloudProfileId = readSingle(rawOptions, "cloud-profile-id");
-  const cloudProfileReuseIfActive = readOptionalBoolean(rawOptions, "cloud-profile-reuse-if-active");
+  const cloudProfileReuseIfActive = readOptionalBoolean(
+    rawOptions,
+    "cloud-profile-reuse-if-active"
+  );
+  const json = readOptionalBoolean(rawOptions, "json");
   const agents = rawOptions.get("agent");
   const skills = rawOptions.get("skill");
   const global = readOptionalBoolean(rawOptions, "global");
@@ -494,10 +719,12 @@ function parseCommandLine(argv) {
   const options = {
     ...workspace === void 0 ? {} : { workspace },
     engineName,
-    ...local === void 0 ? {} : { local },
-    ...cloud === void 0 ? {} : { cloud },
+    ...provider === void 0 ? {} : { provider },
+    ...cloudBaseUrl === void 0 ? {} : { cloudBaseUrl },
+    ...cloudApiKey === void 0 ? {} : { cloudApiKey },
     ...cloudProfileId === void 0 ? {} : { cloudProfileId },
     ...cloudProfileReuseIfActive === void 0 ? {} : { cloudProfileReuseIfActive },
+    ...json === void 0 ? {} : { json },
     ...agents === void 0 ? {} : { agents },
     ...skills === void 0 ? {} : { skills },
     ...global === void 0 ? {} : { global },
@@ -529,41 +756,76 @@ function parseCommandLine(argv) {
     help
   };
 }
-async function resolveCliExecutionMode(parsed) {
-  const environmentMode = process2.env.OPENSTEER_MODE;
-  if (parsed.options.local === void 0 && parsed.options.cloud === void 0 && (environmentMode === void 0 || environmentMode.trim().length === 0) && parsed.options.workspace !== void 0) {
-    const rootPath = resolveFilesystemWorkspacePath({
-      rootDir: process2.cwd(),
-      workspace: parsed.options.workspace
-    });
-    if (await hasPersistedCloudSession(rootPath)) {
-      return "cloud";
-    }
-  }
-  return resolveOpensteerExecutionMode({
-    ...parsed.options.local === void 0 ? {} : { local: parsed.options.local },
-    ...parsed.options.cloud === void 0 ? {} : { cloud: parsed.options.cloud },
-    ...environmentMode === void 0 ? {} : { environment: environmentMode }
-  });
-}
-function buildCliCloudOptions(parsed) {
+function buildCliBrowserProfile(parsed) {
   if (parsed.options.cloudProfileReuseIfActive === true && parsed.options.cloudProfileId === void 0) {
-    throw new Error(
-      '"--cloud-profile-reuse-if-active" requires "--cloud-profile-id <id>".'
-    );
+    throw new Error('"--cloud-profile-reuse-if-active" requires "--cloud-profile-id <id>".');
   }
-  const browserProfile = parsed.options.cloudProfileId === void 0 ? void 0 : {
+  return parsed.options.cloudProfileId === void 0 ? void 0 : {
     profileId: parsed.options.cloudProfileId,
     ...parsed.options.cloudProfileReuseIfActive === true ? { reuseIfActive: true } : {}
   };
-  if (browserProfile !== void 0) {
-    return { browserProfile };
+}
+function buildCliExplicitProvider(parsed) {
+  if (parsed.options.provider === "local") {
+    return { kind: "local" };
   }
-  if (parsed.options.cloud === true) {
-    return true;
+  if (parsed.options.provider === "cloud") {
+    return { kind: "cloud" };
   }
   return void 0;
 }
+function resolveCliProvider(parsed) {
+  const explicitProvider = buildCliExplicitProvider(parsed);
+  return resolveOpensteerProvider({
+    ...explicitProvider === void 0 ? {} : { provider: explicitProvider },
+    ...process2.env.OPENSTEER_PROVIDER === void 0 ? {} : { environmentProvider: process2.env.OPENSTEER_PROVIDER }
+  });
+}
+function buildCliRuntimeProvider(parsed, providerKind) {
+  const explicitProvider = buildCliExplicitProvider(parsed);
+  if (providerKind === "local") {
+    return explicitProvider?.kind === "local" ? explicitProvider : void 0;
+  }
+  const browserProfile = buildCliBrowserProfile(parsed);
+  const hasCloudOverrides = parsed.options.cloudBaseUrl !== void 0 || parsed.options.cloudApiKey !== void 0 || browserProfile !== void 0;
+  if (!hasCloudOverrides && explicitProvider?.kind !== "cloud") {
+    return void 0;
+  }
+  return {
+    kind: "cloud",
+    ...parsed.options.cloudBaseUrl === void 0 ? {} : { baseUrl: parsed.options.cloudBaseUrl },
+    ...parsed.options.cloudApiKey === void 0 ? {} : { apiKey: parsed.options.cloudApiKey },
+    ...browserProfile === void 0 ? {} : { browserProfile }
+  };
+}
+function assertCloudCliOptionsMatchProvider(parsed, providerKind) {
+  if (providerKind !== "cloud" && (parsed.options.cloudBaseUrl !== void 0 || parsed.options.cloudApiKey !== void 0 || parsed.options.cloudProfileId !== void 0 || parsed.options.cloudProfileReuseIfActive === true)) {
+    throw new Error(
+      'Cloud-specific options require provider=cloud. Set "--provider cloud" or OPENSTEER_PROVIDER=cloud.'
+    );
+  }
+}
+async function handleStatusCommand(parsed) {
+  const provider = resolveCliProvider(parsed);
+  assertCloudCliOptionsMatchProvider(parsed, provider.kind);
+  const runtimeProvider = buildCliRuntimeProvider(parsed, provider.kind);
+  const runtimeConfig = resolveOpensteerRuntimeConfig({
+    ...runtimeProvider === void 0 ? {} : { provider: runtimeProvider },
+    ...process2.env.OPENSTEER_PROVIDER === void 0 ? {} : { environmentProvider: process2.env.OPENSTEER_PROVIDER }
+  });
+  const status = await collectOpensteerStatus({
+    rootDir: process2.cwd(),
+    ...parsed.options.workspace === void 0 ? {} : { workspace: parsed.options.workspace },
+    provider,
+    ...runtimeConfig.cloud === void 0 ? {} : { cloudConfig: runtimeConfig.cloud }
+  });
+  if (parsed.options.json === true) {
+    process2.stdout.write(`${JSON.stringify(status, null, 2)}
+`);
+    return;
+  }
+  process2.stdout.write(renderOpensteerStatus(status));
+}
 function parseKeyValueList(values) {
   if (values === void 0 || values.length === 0) {
     return void 0;
@@ -633,6 +895,9 @@ function resolveCommandLength(tokens) {
   if (tokens[0] === "run") {
     return 1;
   }
+  if (tokens[0] === "status") {
+    return 1;
+  }
   for (let length = Math.min(3, tokens.length); length >= 1; length -= 1) {
     if (OPERATION_ALIASES.has(tokens.slice(0, length).join(" "))) {
       return length;
@@ -651,6 +916,7 @@ Usage:
   opensteer input --workspace <id> --text <value> (--element <n> | --selector <css> | --description <text>)
   opensteer extract --workspace <id> --description <text> [--schema-json <json>]
   opensteer close --workspace <id>
+  opensteer status [--workspace <id>] [--json]
 
   opensteer browser status --workspace <id>
   opensteer browser clone --workspace <id> --source-user-data-dir <path> [--source-profile-directory <name>]
@@ -664,10 +930,12 @@ Usage:
 
 Common options:
   --workspace <id>
-  --local
-  --cloud
+  --provider local|cloud
+  --cloud-base-url <url>
+  --cloud-api-key <key>
   --cloud-profile-id <id>
   --cloud-profile-reuse-if-active <true|false>
+  --json <true|false>
   --engine playwright|abp
   --browser temporary|persistent|attach
   --attach-endpoint <url>