surf-cli 2.16.1 → 2.18.0

package/native/oracle-cli.cjs

@@ -1,16 +1,30 @@
 const { openClientTransport } = require("./client-transport.cjs");
 const { resolveRequestDeadlineMs } = require("./host-sessions.cjs");
 const { assembleContext } = require("./oracle-context.cjs");
+const fs = require("fs");
+const path = require("path");
 
 const RESULT_TIMEOUT_SECONDS = 20;
 const POLL_DELAYS_MS = [5000, 10000, 20000, 40000, 60000];
 const ORACLE_ERROR_CODES = new Set([
   "auth",
+  "attachment_chooser_interception",
+  "attachment_file_access",
+  "attachment_processing",
+  "attachment_selector_drift",
   "capacity",
+  "chat_mode_selection_failed",
+  "chat_mode_selector_drift",
+  "chat_mode_unavailable",
   "cloudflare",
   "context_incomplete",
   "dispatch_failed",
+  "github_tool_disconnected",
+  "github_tool_missing",
+  "github_tool_selection_failed",
+  "github_tool_selector_drift",
   "harvest_failed",
+  "invalid_request",
   "invalid_transition",
   "model_verification_failed",
   "not_found",
@@ -30,8 +44,10 @@ Commands:
 
 Ask/follow options:
   --files <glob>          Add context files (repeatable)
-  --model <model>         Select model: instant, thinking, pro, gpt-5.5, gpt-5.6-sol
-  --effort <effort>       Select effort: light, standard, extended, heavy, pro
+  --file <path>           Attach one local file
+  --model <model>         Select model: gpt-6-astra, latest, gpt-5.6-sol, gpt-5.5
+  --effort <effort>       Select effort: instant, medium, high, xhigh, pro
+  --github                Require the ChatGPT Chat tab and GitHub tool
   --detach                Return after dispatch
   --allow-sensitive       Allow deny-listed context files
 
@@ -56,11 +72,12 @@ function requireOptionValue(argv, index, name) {
 
 function parseOptions(argv) {
   const positional = [];
-  const options = { files: [] };
-  const valueOptions = new Set(["files", "model", "effort"]);
+  const options = { files: [], file: [] };
+  const valueOptions = new Set(["files", "file", "model", "effort"]);
   const booleanOptions = new Set([
     "allow-sensitive",
     "detach",
+    "github",
     "json",
     "no-lock",
     "wait",
@@ -75,7 +92,7 @@ function parseOptions(argv) {
     const name = value.slice(2);
     if (valueOptions.has(name)) {
       const optionValue = requireOptionValue(argv, index, name);
-      if (name === "files") options.files.push(optionValue);
+      if (name === "files" || name === "file") options[name].push(optionValue);
       else options[name] = optionValue;
       index += 1;
     } else if (booleanOptions.has(name)) {
@@ -94,14 +111,16 @@ function assertAllowedOptions(command, options) {
     "allow-sensitive",
     "detach",
     "effort",
+    "file",
     "files",
+    "github",
     "model",
   ]);
   const allowed = command === "ask" || command === "follow"
     ? ask
     : command === "result" ? new Set([...common, "wait"]) : common;
   for (const [name, value] of Object.entries(options)) {
-    if (name === "files" && value.length === 0) continue;
+    if ((name === "files" || name === "file") && value.length === 0) continue;
     if (value !== undefined && !allowed.has(name)) {
       throw codedError("invalid_transition", `--${name} is not supported by oracle ${command}`);
     }
@@ -131,8 +150,12 @@ function parseOracleCommand(argv) {
       command,
       prompt,
       files: parsed.options.files,
+      ...(parsed.options.file.length > 0
+        ? { file: parsed.options.file.length === 1 ? parsed.options.file[0] : parsed.options.file }
+        : {}),
       model: parsed.options.model,
       effort: parsed.options.effort,
+      github: parsed.options.github === true,
       detach: parsed.options.detach === true,
       allowSensitive: parsed.options["allow-sensitive"] === true,
       json,
@@ -151,8 +174,12 @@ function parseOracleCommand(argv) {
       id,
       prompt,
       files: parsed.options.files,
+      ...(parsed.options.file.length > 0
+        ? { file: parsed.options.file.length === 1 ? parsed.options.file[0] : parsed.options.file }
+        : {}),
       model: parsed.options.model,
       effort: parsed.options.effort,
+      github: parsed.options.github === true,
       detach: parsed.options.detach === true,
       allowSensitive: parsed.options["allow-sensitive"] === true,
       json,
@@ -191,12 +218,44 @@ function composeAskRequest(spec, context) {
     prompt,
     ...(spec.model ? { model: spec.model } : {}),
     ...(spec.effort ? { effort: spec.effort } : {}),
+    ...(spec.file ? { file: spec.file } : {}),
+    ...(spec.github ? { github: true } : {}),
     ...(context ? { contextManifest: context.manifest } : {}),
     ...(context?.bundlePath ? { bundlePath: context.bundlePath } : {}),
     ...(spec.id ? { follow: spec.id } : {}),
   };
 }
 
+async function resolveOracleAttachment(value, cwd = process.cwd()) {
+  const values = value === undefined || value === null
+    ? []
+    : Array.isArray(value) ? value : [value];
+  if (values.length > 1) {
+    throw codedError(
+      "attachment_file_access",
+      "Oracle supports one explicit local attachment; provide a single --file path",
+    );
+  }
+  if (values.length === 0) return undefined;
+  const requested = values[0];
+  if (typeof requested !== "string" || !requested.trim()) {
+    throw codedError("attachment_file_access", "Oracle attachment file access failed: --file must be a path");
+  }
+  const resolved = path.resolve(cwd, requested);
+  try {
+    const stats = await fs.promises.stat(resolved);
+    if (!stats.isFile()) throw new Error("not a regular file");
+    await fs.promises.access(resolved, fs.constants.R_OK);
+  } catch (error) {
+    throw codedError(
+      "attachment_file_access",
+      `Oracle attachment file access failed for ${resolved}: ${error?.message || error}`,
+      { path: resolved },
+    );
+  }
+  return resolved;
+}
+
 function unwrapResponse(response) {
   if (response?.error) {
     const message = response.error.message
@@ -389,6 +448,7 @@ async function handleOracleCli(argv, {
     }
   }
 
+  const attachment = await resolveOracleAttachment(spec.file, cwd);
   const context = spec.files.length > 0
     ? await assembleContext({
       files: spec.files,
@@ -396,7 +456,7 @@ async function handleOracleCli(argv, {
       allowSensitive: spec.allowSensitive,
     })
     : null;
-  const request = composeAskRequest(spec, context);
+  const request = composeAskRequest({ ...spec, ...(attachment ? { file: attachment } : {}) }, context);
   const dispatchInterrupt = () => {
     stderr.write(
       "Interrupted during dispatch. A job may already have been created. Run surf oracle status or surf oracle list to find it.\n",
@@ -430,5 +490,6 @@ module.exports = {
   formatOracleOutput,
   handleOracleCli,
   parseOracleCommand,
+  resolveOracleAttachment,
   shapeOracleError,
 };

package/native/oracle-host.cjs

@@ -1,3 +1,5 @@
+const fs = require("fs");
+const path = require("path");
 const chatgptClient = require("./chatgpt-client.cjs");
 const oracleJobs = require("./oracle-jobs.cjs");
 
@@ -23,6 +25,39 @@ function withJobId(error, jobId, fallbackCode) {
   return result;
 }
 
+async function resolveOracleAttachments(args) {
+  const explicit = args?.file === undefined || args?.file === null
+    ? []
+    : Array.isArray(args.file) ? args.file : [args.file];
+  if (explicit.length > 1) {
+    throw codedError(
+      "attachment_file_access",
+      "Oracle supports one explicit local attachment; provide a single --file path",
+    );
+  }
+  const requested = [...explicit, ...(args?.bundlePath ? [args.bundlePath] : [])];
+  const resolved = [];
+  for (const filePath of requested) {
+    if (typeof filePath !== "string" || !filePath.trim()) {
+      throw codedError("attachment_file_access", "Oracle attachment file access failed: file path is required");
+    }
+    const absolutePath = path.resolve(filePath);
+    try {
+      const stats = await fs.promises.stat(absolutePath);
+      if (!stats.isFile()) throw new Error("not a regular file");
+      await fs.promises.access(absolutePath, fs.constants.R_OK);
+    } catch (error) {
+      throw codedError(
+        "attachment_file_access",
+        `Oracle attachment file access failed for ${absolutePath}: ${error?.message || error}`,
+        { path: absolutePath },
+      );
+    }
+    resolved.push(absolutePath);
+  }
+  return resolved;
+}
+
 function createOracleHost({ queueAiRequest, requestCallExtension, buildProviderUploadMessage, log }) {
   const closeTab = (request, tabId) => requestCallExtension(
     request,
@@ -65,6 +100,7 @@ function createOracleHost({ queueAiRequest, requestCallExtension, buildProviderU
   async function ask(request, args) {
     assertLocalOracleRequest(request);
     const model = args.model ? chatgptClient.normalizeChatGPTModelChoice(args.model) : null;
+    const explicitAttachmentPaths = await resolveOracleAttachments({ ...args, bundlePath: undefined });
     const created = oracleJobs.createJob({
       prompt: args.prompt,
       contextManifest: args.contextManifest,
@@ -72,11 +108,16 @@ function createOracleHost({ queueAiRequest, requestCallExtension, buildProviderU
       effortRequested: args.effort ?? null,
       follow: args.follow ?? null,
       requestId: args.requestId ?? null,
+      attachmentPaths: explicitAttachmentPaths,
+      github: args.github === true,
     });
     if (created.requestDeduped) return oracleJobs.getJob(created.id);
     let createdTabId = null;
 
     try {
+      const attachmentPaths = args?.bundlePath
+        ? [...explicitAttachmentPaths, ...(await resolveOracleAttachments({ bundlePath: args.bundlePath }))]
+        : explicitAttachmentPaths;
       let parent = null;
       if (args.follow) {
         parent = oracleJobs.getJob(args.follow);
@@ -93,7 +134,10 @@ function createOracleHost({ queueAiRequest, requestCallExtension, buildProviderU
         prompt: args.prompt,
         model,
         effort: args.effort,
-        file: args.bundlePath,
+        file: attachmentPaths.length > 0
+          ? attachmentPaths.length === 1 ? attachmentPaths[0] : attachmentPaths
+          : undefined,
+        ...(args.github === true ? { github: true } : {}),
         startUrl: parent?.conversationUrl,
         createTab: async () => {
           const tabInfo = await browserOptions(request).createTab();
@@ -304,4 +348,4 @@ function createOracleHost({ queueAiRequest, requestCallExtension, buildProviderU
   };
 }
 
-module.exports = { assertLocalOracleRequest, createOracleHost };
+module.exports = { assertLocalOracleRequest, createOracleHost, resolveOracleAttachments };

package/native/oracle-jobs.cjs

@@ -47,13 +47,15 @@ function stableJson(value) {
   return JSON.stringify(value) ?? "null";
 }
 
-function requestFingerprint({ prompt, contextManifest, model, effortRequested, follow }) {
+function requestFingerprint({ prompt, contextManifest, model, effortRequested, follow, attachmentPaths, github }) {
   return promptDigest(stableJson({
     promptDigest: promptDigest(prompt),
     contextManifest: contextManifest ?? {},
     model: model ?? null,
     effortRequested: effortRequested ?? null,
     follow: follow ?? null,
+    attachmentPaths: attachmentPaths ?? [],
+    github: github === true,
   }));
 }
 
@@ -92,13 +94,13 @@ function readJobs(root = getPrivateStateRoot()) {
     .map((job) => hydrateJobMetadata(job, root));
 }
 
-function createJob({ prompt, contextManifest = {}, model = null, effortRequested = null, follow = null, requestId = null }) {
+function createJob({ prompt, contextManifest = {}, model = null, effortRequested = null, follow = null, requestId = null, attachmentPaths = [], github = false }) {
   const root = getPrivateStateRoot();
   const base = oracleRoot(root);
   ensurePrivateDir(base, root);
   const safeRequestId = normalizedRequestId(requestId);
   const fingerprint = safeRequestId
-    ? requestFingerprint({ prompt, contextManifest, model, effortRequested, follow })
+    ? requestFingerprint({ prompt, contextManifest, model, effortRequested, follow, attachmentPaths, github })
     : null;
   if (safeRequestId) {
     const existing = readJobs(root).find((job) => job.requestId === safeRequestId);

package/native/socket-permissions.cjs

@@ -0,0 +1,114 @@
+const fs = require("fs");
+const { execFileSync } = require("child_process");
+
+const DEFAULT_SOCKET_MODE = 0o600;
+const ALLOWED_SOCKET_MODES = new Set([0o600, 0o660]);
+const MAX_GID = 0xfffffffe;
+const SOCKET_GROUP_PATTERN = /^(?:\d+|[A-Za-z_][A-Za-z0-9_.-]*)$/;
+
+function parseSocketMode(value) {
+  if (value === undefined) return DEFAULT_SOCKET_MODE;
+  if (typeof value === "number" && ALLOWED_SOCKET_MODES.has(value)) return value;
+  if (value === 600) return DEFAULT_SOCKET_MODE;
+  if (value === 660) return 0o660;
+  const text = String(value).trim();
+  if (!/^0?(?:600|660)$/.test(text)) {
+    throw new Error("SURF_SOCKET_MODE must be 600 or 660");
+  }
+  return Number.parseInt(text, 8);
+}
+
+function validateSocketGroup(value) {
+  if (value === undefined) return undefined;
+  if (value === null || typeof value === "boolean") {
+    throw new Error("SURF_SOCKET_GROUP must be a numeric gid or a simple group name");
+  }
+  const group = String(value).trim();
+  if (!SOCKET_GROUP_PATTERN.test(group)) {
+    throw new Error("SURF_SOCKET_GROUP must be a numeric gid or a simple group name");
+  }
+  if (/^\d+$/.test(group)) {
+    const gid = Number(group);
+    if (!Number.isSafeInteger(gid) || gid < 0 || gid > MAX_GID) {
+      throw new Error("SURF_SOCKET_GROUP gid is out of range");
+    }
+  }
+  return group;
+}
+
+function normalizeSocketConfig(socketMode, socketGroup) {
+  const mode = socketMode === undefined ? undefined : parseSocketMode(socketMode);
+  const group = socketGroup === undefined ? undefined : validateSocketGroup(socketGroup);
+  if (mode === 0o660 && !group) {
+    throw new Error("SURF_SOCKET_MODE=660 requires SURF_SOCKET_GROUP");
+  }
+  return { mode, group };
+}
+
+function resolveSocketGroup(value) {
+  const group = validateSocketGroup(value);
+  if (group === undefined) return undefined;
+  if (/^\d+$/.test(group)) return Number(group);
+
+  const command = process.platform === "darwin" ? "dscl" : "getent";
+  const args = process.platform === "darwin"
+    ? [".", "-read", `/Groups/${group}`, "PrimaryGroupID"]
+    : ["group", group];
+  let output;
+  try {
+    output = execFileSync(command, args, { encoding: "utf8", stdio: ["ignore", "pipe", "pipe"] });
+  } catch (error) {
+    throw new Error(`could not resolve socket group ${group}: ${error.message}`);
+  }
+  const match = process.platform === "darwin"
+    ? output.match(/\bPrimaryGroupID:\s*(\d+)\b/)
+    : output.trim().split(/\r?\n/, 1)[0]?.split(":")[2]?.match(/^\d+$/);
+  const gid = Number(match?.[1] || match?.[0]);
+  if (!Number.isSafeInteger(gid) || gid < 0 || gid > MAX_GID) {
+    throw new Error(`could not resolve socket group ${group}`);
+  }
+  return gid;
+}
+
+function resolveSocketPermissions(socketMode, socketGroup) {
+  const config = normalizeSocketConfig(socketMode, socketGroup);
+  const mode = config.mode ?? DEFAULT_SOCKET_MODE;
+  const gid = resolveSocketGroup(config.group);
+  return { mode, group: config.group, gid };
+}
+
+function assertSocketPath(socketPath) {
+  let stat;
+  try {
+    stat = fs.lstatSync(socketPath);
+  } catch (error) {
+    throw new Error(`could not inspect local socket: ${error.message}`);
+  }
+  if (stat.isSymbolicLink()) throw new Error("refusing symbolic-link local socket");
+  if (!stat.isSocket()) throw new Error("local socket path is not a Unix socket");
+  return stat;
+}
+
+function applySocketPermissions(socketPath, permissions) {
+  const before = assertSocketPath(socketPath);
+  if (permissions.gid !== undefined) {
+    fs.chownSync(socketPath, before.uid, permissions.gid);
+  }
+  fs.chmodSync(socketPath, permissions.mode);
+  const after = assertSocketPath(socketPath);
+  if ((after.mode & 0o7777) !== permissions.mode) {
+    throw new Error(`local socket mode is not ${permissions.mode.toString(8)}`);
+  }
+  if (permissions.gid !== undefined && after.gid !== permissions.gid) {
+    throw new Error(`local socket group is not ${permissions.group}`);
+  }
+  return after;
+}
+
+module.exports = {
+  applySocketPermissions,
+  normalizeSocketConfig,
+  parseSocketMode,
+  resolveSocketPermissions,
+  validateSocketGroup,
+};

package/native/tool-scope.cjs

@@ -21,7 +21,7 @@ const BROWSER_READ_TOOLS = new Set([
 ]);
 
 const BROWSER_WRITE_TOOLS = new Set([
-  "session.new", "session.ensure", "session.close", "session.rebind", "session.reopen",
+  "session.new", "session.ensure", "session.cleanup", "session.close", "session.rebind", "session.reopen",
   "tab.new", "new_tab", "tabs_create",
   "tab.move", "tab.switch", "switch_tab",
   "tab.group", "tab.ungroup",
@@ -36,7 +36,7 @@ const BROWSER_WRITE_TARGETED_TOOLS = new Set([
 ]);
 
 const TAB_TOOLS = new Set([
-  "ai", "computer", "batch", "record", "animate-audit", "perf-audit",
+  "ai", "computer", "batch", "record", "video.start", "animate-audit", "perf-audit",
   "navigate", "go", "back", "forward", "reload", "tab.reload",
   "screenshot", "snap", "resize",
   "page.read", "read_page", "page.text", "get_page_text", "page.html", "page.save", "page.state",
@@ -87,10 +87,14 @@ function classifyTool(tool, args = {}) {
     return { scope: "browser-write", targetUse: "default-tab" };
   }
   if (BROWSER_WRITE_TOOLS.has(tool)) return { scope: "browser-write", targetUse: "browser" };
+  if (tool === "video.stop" || tool === "video.status" || tool === "video.restart") {
+    return { scope: "host", targetUse: "host", resourceKeys: ["video-recorder"] };
+  }
   if (TAB_TOOLS.has(tool)) {
     const resourceKeys = [];
     if (tool === "network.export" && typeof args.output === "string") resourceKeys.push(`file:${path.resolve(args.output)}`);
     if (tool.startsWith("playbook.record.")) resourceKeys.push("playbook-recorder");
+    if (tool === "video.start") resourceKeys.push("video-recorder");
     return { scope: "tab", targetUse: "default-tab", resourceKeys };
   }
   return { scope: "browser-write", targetUse: "browser", conservative: true };