@github/copilot-language-server 1.528.0 → 1.530.0

package/dist/node_modules/@github/copilot-sdk/dist/cjs/extension.js

@@ -20,13 +20,17 @@ var extension_exports = {};
 __export(extension_exports, {
   Canvas: () => import_canvas.Canvas,
   CanvasError: () => import_canvas.CanvasError,
+  FactoryResumeError: () => import_factory.FactoryResumeError,
   createCanvas: () => import_canvas.createCanvas,
+  defineFactory: () => import_factory.defineFactory,
+  isFactoryRunTerminal: () => import_factory.isFactoryRunTerminal,
   joinSession: () => joinSession
 });
 module.exports = __toCommonJS(extension_exports);
 var import_client = require("./client.js");
 var import_types = require("./types.js");
 var import_canvas = require("./canvas.js");
+var import_factory = require("./factory.js");
 async function joinSession(config = {}) {
   const sessionId = process.env.SESSION_ID;
   if (!sessionId) {
@@ -35,18 +39,29 @@ async function joinSession(config = {}) {
     );
   }
   const client = new import_client.CopilotClient({ _internalConnection: { kind: "parent-process" } });
-  const { extensionSdkPath: _stripped, ...rest } = config;
+  const {
+    extensionSdkPath: _stripped,
+    factories,
+    ...rest
+  } = config;
   void _stripped;
-  return client.resumeSession(sessionId, {
-    ...rest,
-    onPermissionRequest: config.onPermissionRequest ?? import_types.defaultJoinSessionPermissionHandler,
-    suppressResumeEvent: config.suppressResumeEvent ?? true
-  });
+  return client.resumeSessionForExtension(
+    sessionId,
+    {
+      ...rest,
+      onPermissionRequest: config.onPermissionRequest ?? import_types.defaultJoinSessionPermissionHandler,
+      suppressResumeEvent: config.suppressResumeEvent ?? true
+    },
+    factories
+  );
 }
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   Canvas,
   CanvasError,
+  FactoryResumeError,
   createCanvas,
+  defineFactory,
+  isFactoryRunTerminal,
   joinSession
 });

package/dist/node_modules/@github/copilot-sdk/dist/cjs/factory.js

@@ -0,0 +1,123 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var factory_exports = {};
+__export(factory_exports, {
+  FactoryResumeError: () => FactoryResumeError,
+  defineFactory: () => defineFactory,
+  getFactoryDefinition: () => getFactoryDefinition,
+  isFactoryRunTerminal: () => isFactoryRunTerminal
+});
+module.exports = __toCommonJS(factory_exports);
+const FACTORY_TERMINAL_STATUSES = /* @__PURE__ */ new Set([
+  "completed",
+  "halted",
+  "cancelled",
+  "error"
+]);
+function isFactoryRunTerminal(status) {
+  return FACTORY_TERMINAL_STATUSES.has(status);
+}
+class FactoryResumeError extends Error {
+  constructor(code, message) {
+    super(message);
+    this.code = code;
+    this.name = "FactoryResumeError";
+  }
+  code;
+}
+const factoryHandles = /* @__PURE__ */ new WeakMap();
+const MAX_FACTORY_TIMEOUT_SECONDS = 2147483647e-3;
+const NANO_AIU_PER_AIU = 1e9;
+function deepFreeze(value) {
+  if (value !== null && typeof value === "object" && !Object.isFrozen(value)) {
+    Object.freeze(value);
+    for (const nested of Object.values(value)) {
+      deepFreeze(nested);
+    }
+  }
+  return value;
+}
+function validateLimits(meta) {
+  const limits = meta.limits;
+  if (!limits) {
+    return;
+  }
+  for (const field of ["maxConcurrentSubagents", "maxTotalSubagents"]) {
+    const value = limits[field];
+    if (value !== void 0 && (!Number.isInteger(value) || value <= 0)) {
+      throw new Error(`Factory limit "${field}" must be a positive integer`);
+    }
+  }
+  if (limits.timeoutSeconds !== void 0 && (!Number.isFinite(limits.timeoutSeconds) || limits.timeoutSeconds <= 0)) {
+    throw new Error(
+      'Factory limit "timeoutSeconds" must be a positive, finite number of seconds'
+    );
+  }
+  if (limits.timeoutSeconds !== void 0 && limits.timeoutSeconds > MAX_FACTORY_TIMEOUT_SECONDS) {
+    throw new Error(
+      `Factory limit "timeoutSeconds" must not exceed ${MAX_FACTORY_TIMEOUT_SECONDS} seconds`
+    );
+  }
+  if (limits.maxAiCredits !== void 0) {
+    const maxNanoAiu = Math.round(limits.maxAiCredits * NANO_AIU_PER_AIU);
+    if (!Number.isFinite(limits.maxAiCredits) || limits.maxAiCredits <= 0 || !Number.isSafeInteger(maxNanoAiu) || maxNanoAiu < 1) {
+      throw new Error(
+        'Factory limit "maxAiCredits" must be a positive, finite number that rounds to a safe positive integer nano-AIU ceiling'
+      );
+    }
+  }
+}
+function validatePhases(meta) {
+  const titles = /* @__PURE__ */ new Set();
+  for (const phase of meta.phases) {
+    if (phase.title.trim().length === 0) {
+      throw new Error("Factory phase titles must not be empty");
+    }
+    if (titles.has(phase.title)) {
+      throw new Error(`Factory phase title "${phase.title}" is declared more than once`);
+    }
+    titles.add(phase.title);
+  }
+}
+function defineFactory(definition) {
+  const meta = deepFreeze(structuredClone(definition.meta));
+  validateLimits(meta);
+  validatePhases(meta);
+  const stored = {
+    meta,
+    run: definition.run
+  };
+  const handle = Object.freeze({ meta });
+  factoryHandles.set(handle, stored);
+  return handle;
+}
+function getFactoryDefinition(handle) {
+  const definition = factoryHandles.get(handle);
+  if (!definition) {
+    throw new Error("Invalid factory handle");
+  }
+  return definition;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  FactoryResumeError,
+  defineFactory,
+  getFactoryDefinition,
+  isFactoryRunTerminal
+});

package/dist/node_modules/@github/copilot-sdk/dist/cjs/ffiRuntimeHost.js

@@ -0,0 +1,285 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var ffiRuntimeHost_exports = {};
+__export(ffiRuntimeHost_exports, {
+  FfiRuntimeHost: () => FfiRuntimeHost
+});
+module.exports = __toCommonJS(ffiRuntimeHost_exports);
+var import_node_fs = require("node:fs");
+var import_koffi = __toESM(require("koffi"), 1);
+var import_node_path = require("node:path");
+var import_node_stream = require("node:stream");
+const SYMBOL_PREFIX = "copilot_runtime_";
+const KEEP_ALIVE_INTERVAL_MS = 1 << 30;
+let loadedLibraryPath;
+let loadedLibrary;
+function loadLibrary(libraryPath) {
+  if (loadedLibrary) {
+    if (loadedLibraryPath !== libraryPath) {
+      throw new Error(
+        `An in-process FFI runtime library is already loaded from '${loadedLibraryPath}'; loading a different library from '${libraryPath}' in the same process is not supported.`
+      );
+    }
+    return loadedLibrary;
+  }
+  const lib = import_koffi.default.load(libraryPath);
+  const outboundCallbackType = import_koffi.default.pointer(
+    import_koffi.default.proto(
+      `void ${SYMBOL_PREFIX}outbound(void *userData, uint8 *bytesPtr, size_t bytesLen)`
+    )
+  );
+  loadedLibrary = {
+    hostStart: lib.func(`${SYMBOL_PREFIX}host_start`, "uint32", [
+      "uint8*",
+      "size_t",
+      "uint8*",
+      "size_t"
+    ]),
+    hostShutdown: lib.func(`${SYMBOL_PREFIX}host_shutdown`, "bool", ["uint32"]),
+    connectionOpen: lib.func(`${SYMBOL_PREFIX}connection_open`, "uint32", [
+      "uint32",
+      outboundCallbackType,
+      "void*",
+      "uint8*",
+      "size_t",
+      "uint8*",
+      "size_t",
+      "uint8*",
+      "size_t"
+    ]),
+    connectionWrite: lib.func(`${SYMBOL_PREFIX}connection_write`, "bool", [
+      "uint32",
+      "uint8*",
+      "size_t"
+    ]),
+    connectionClose: lib.func(`${SYMBOL_PREFIX}connection_close`, "bool", ["uint32"]),
+    outboundCallbackType
+  };
+  loadedLibraryPath = libraryPath;
+  return loadedLibrary;
+}
+function buildArgvJson(cliEntrypoint, args) {
+  const argv = cliEntrypoint.toLowerCase().endsWith(".js") ? ["node", cliEntrypoint, "--embedded-host", "--no-auto-update"] : [cliEntrypoint, "--embedded-host", "--no-auto-update"];
+  argv.push(...args);
+  return Buffer.from(JSON.stringify(argv), "utf8");
+}
+function buildEnvJson(environment) {
+  if (!environment) {
+    return null;
+  }
+  const obj = {};
+  for (const [key, value] of Object.entries(environment)) {
+    if (value !== void 0) {
+      obj[key] = value;
+    }
+  }
+  if (Object.keys(obj).length === 0) {
+    return null;
+  }
+  return Buffer.from(JSON.stringify(obj), "utf8");
+}
+class FfiRuntimeHost {
+  constructor(libraryPath, cliEntrypoint, environment, args) {
+    this.libraryPath = libraryPath;
+    this.cliEntrypoint = cliEntrypoint;
+    this.environment = environment;
+    this.args = args;
+    this.lib = loadLibrary(libraryPath);
+    this.receiveStream = new import_node_stream.PassThrough();
+    this.sendStream = new import_node_stream.Writable({
+      // connection_write enqueues the frame into the runtime's inbound channel and
+      // returns immediately, so a synchronous FFI call is sufficient here.
+      write: (chunk, _encoding, callback) => {
+        try {
+          this.writeFrame(chunk);
+          callback();
+        } catch (error) {
+          callback(error);
+        }
+      }
+    });
+  }
+  libraryPath;
+  cliEntrypoint;
+  environment;
+  args;
+  lib;
+  serverId = 0;
+  connectionId = 0;
+  disposed = false;
+  outboundCallback;
+  keepAliveTimer;
+  /** The stream JSON-RPC reads server→client frames from. */
+  receiveStream;
+  /** The stream JSON-RPC writes client→server frames to. */
+  sendStream;
+  /**
+   * Resolves the cdylib next to the given CLI entrypoint and prepares the FFI host.
+   * The cdylib is resolved as `prebuilds/<prebuildsFolder>/runtime.node` relative to
+   * the entrypoint directory (the napi-rs `<node-platform>-<arch>` layout, e.g.
+   * `linux-x64`). Throws if it cannot be found.
+   */
+  static create(cliEntrypoint, prebuildsFolder, environment, args) {
+    const fullEntrypoint = (0, import_node_path.resolve)(cliEntrypoint);
+    const distDir = (0, import_node_path.dirname)(fullEntrypoint);
+    const libraryPath = (0, import_node_path.join)(distDir, "prebuilds", prebuildsFolder, "runtime.node");
+    if (!(0, import_node_fs.existsSync)(libraryPath)) {
+      throw new Error(`FFI runtime library not found. Looked for '${libraryPath}'.`);
+    }
+    return new FfiRuntimeHost(libraryPath, fullEntrypoint, environment, args);
+  }
+  /**
+   * Starts the in-process runtime: spawns the CLI worker via the native host,
+   * waits for readiness, and opens the FFI JSON-RPC connection.
+   */
+  async start() {
+    const argvJson = buildArgvJson(this.cliEntrypoint, this.args);
+    const envJson = buildEnvJson(this.environment);
+    this.serverId = await new Promise((resolvePromise, rejectPromise) => {
+      this.lib.hostStart.async(
+        argvJson,
+        argvJson.length,
+        envJson,
+        envJson ? envJson.length : 0,
+        (error, result) => {
+          if (error) {
+            rejectPromise(error);
+          } else {
+            resolvePromise(result);
+          }
+        }
+      );
+    });
+    if (!this.serverId) {
+      throw new Error(
+        `copilot_runtime_host_start failed (library '${this.libraryPath}', entrypoint '${this.cliEntrypoint}').`
+      );
+    }
+    this.outboundCallback = import_koffi.default.register(
+      (_userData, bytesPtr, bytesLen) => this.feedInbound(bytesPtr, bytesLen),
+      this.lib.outboundCallbackType
+    );
+    this.connectionId = this.lib.connectionOpen(
+      this.serverId,
+      this.outboundCallback,
+      null,
+      null,
+      0,
+      null,
+      0,
+      null,
+      0
+    );
+    if (!this.connectionId) {
+      this.unregisterCallback();
+      this.lib.hostShutdown(this.serverId);
+      this.serverId = 0;
+      throw new Error("copilot_runtime_connection_open failed.");
+    }
+    this.keepAliveTimer = setInterval(() => {
+    }, KEEP_ALIVE_INTERVAL_MS);
+  }
+  writeFrame(frame) {
+    if (this.disposed || !this.connectionId) {
+      throw new Error("The in-process runtime connection is closed.");
+    }
+    const ok = this.lib.connectionWrite(this.connectionId, frame, frame.length);
+    if (!ok) {
+      throw new Error("Failed to write a frame to the in-process runtime connection.");
+    }
+  }
+  /**
+   * Native outbound (server→client) callback. koffi delivers it on the JS event loop
+   * via a threadsafe function, so the frame is decoded and written straight to
+   * {@link receiveStream}. The native pointer is only valid for this call, so the
+   * bytes are copied out before returning.
+   */
+  feedInbound(bytesPtr, bytesLen) {
+    try {
+      if (this.disposed || this.receiveStream.writableEnded) {
+        return;
+      }
+      const length = Number(bytesLen);
+      if (!bytesPtr || length <= 0) {
+        return;
+      }
+      const bytes = import_koffi.default.decode(
+        bytesPtr,
+        import_koffi.default.array("uint8", length, "Typed")
+      );
+      this.receiveStream.write(Buffer.from(bytes));
+    } catch (error) {
+      console.error(
+        `In-process FFI inbound callback failed: ${error instanceof Error ? error.stack ?? error.message : String(error)}`
+      );
+    }
+  }
+  unregisterCallback() {
+    if (this.outboundCallback === void 0) {
+      return;
+    }
+    const callback = this.outboundCallback;
+    this.outboundCallback = void 0;
+    try {
+      import_koffi.default.unregister(callback);
+    } catch {
+    }
+  }
+  /** Closes the FFI connection, shuts down the native host, and releases resources. */
+  dispose() {
+    if (this.disposed) {
+      return;
+    }
+    this.disposed = true;
+    if (this.keepAliveTimer !== void 0) {
+      clearInterval(this.keepAliveTimer);
+      this.keepAliveTimer = void 0;
+    }
+    try {
+      if (this.connectionId) {
+        this.lib.connectionClose(this.connectionId);
+        this.connectionId = 0;
+      }
+    } catch {
+    }
+    try {
+      if (this.serverId) {
+        this.lib.hostShutdown(this.serverId);
+        this.serverId = 0;
+      }
+    } catch {
+    }
+    this.receiveStream.end();
+    this.unregisterCallback();
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  FfiRuntimeHost
+});