@ycodium-ai/agent-opencode 0.2.2167 → 0.2.2169

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (2) hide show
  1. package/dist/index.js +224 -166
  2. package/package.json +2 -2
package/dist/index.js CHANGED
@@ -7125,12 +7125,13 @@ async function terminateOwnedProcess(handle) {
7125
7125
  await handle.kill("SIGTERM");
7126
7126
  } catch {
7127
7127
  }
7128
+ let timer;
7128
7129
  const timed = await Promise.race([
7129
7130
  handle.exited.then(() => "exited"),
7130
7131
  new Promise((resolve2) => {
7131
- setTimeout(() => resolve2("timeout"), 2e3);
7132
+ timer = setTimeout(() => resolve2("timeout"), 2e3);
7132
7133
  })
7133
- ]);
7134
+ ]).finally(() => clearTimeout(timer));
7134
7135
  if (timed === "timeout") {
7135
7136
  try {
7136
7137
  await handle.kill("SIGKILL");
@@ -7142,7 +7143,7 @@ async function terminateOwnedProcess(handle) {
7142
7143
  } catch {
7143
7144
  }
7144
7145
  }
7145
- await handle.exited.catch(() => void 0);
7146
+ await handle.exited;
7146
7147
  }
7147
7148
  }
7148
7149
  async function spawnOpenCodeServer(input) {
@@ -7161,6 +7162,7 @@ async function spawnOpenCodeServer(input) {
7161
7162
  kill: spawned.kill,
7162
7163
  exited: spawned.exited
7163
7164
  };
7165
+ input.onSpawn?.({ external: false, process: processHandle });
7164
7166
  const timeoutMs = input.timeoutMs ?? DEFAULT_OPENCODE_SERVER_TIMEOUT_MS;
7165
7167
  let stdoutText = "";
7166
7168
  let settled = false;
@@ -7168,7 +7170,7 @@ async function spawnOpenCodeServer(input) {
7168
7170
  const fail = (cause) => {
7169
7171
  if (settled) return;
7170
7172
  settled = true;
7171
- void terminateOwnedProcess(processHandle);
7173
+ clearTimeout(timer);
7172
7174
  reject(cause instanceof Error ? cause : new Error(String(cause)));
7173
7175
  };
7174
7176
  const timer = setTimeout(() => {
@@ -7181,14 +7183,13 @@ async function spawnOpenCodeServer(input) {
7181
7183
  void (async () => {
7182
7184
  try {
7183
7185
  for await (const chunk of spawned.stdout) {
7186
+ if (settled) continue;
7184
7187
  stdoutText += Buffer.from(chunk).toString("utf8");
7185
7188
  const parsed = parseServerUrlFromOutput(stdoutText);
7186
7189
  if (parsed) {
7187
- if (settled) return;
7188
7190
  settled = true;
7189
7191
  clearTimeout(timer);
7190
7192
  resolve2(parsed);
7191
- return;
7192
7193
  }
7193
7194
  }
7194
7195
  fail(
@@ -7198,11 +7199,21 @@ async function spawnOpenCodeServer(input) {
7198
7199
  fail(cause);
7199
7200
  }
7200
7201
  })();
7201
- void spawned.exited.then((code) => {
7202
- if (!settled) {
7203
- fail(new Error(`OpenCode server exited with code ${code}. stdout=${stdoutText.trim()}`));
7202
+ void (async () => {
7203
+ try {
7204
+ for await (const chunk of spawned.stderr) {
7205
+ void chunk;
7206
+ }
7207
+ } catch (cause) {
7208
+ fail(cause);
7204
7209
  }
7205
- });
7210
+ })();
7211
+ void spawned.exited.then((code) => {
7212
+ fail(new Error(`OpenCode server exited with code ${code}. stdout=${stdoutText.trim()}`));
7213
+ }, fail);
7214
+ }).catch(async (cause) => {
7215
+ await terminateOwnedProcess(processHandle);
7216
+ throw cause;
7206
7217
  });
7207
7218
  return {
7208
7219
  url,
@@ -7232,7 +7243,8 @@ async function connectToOpenCodeServer(input) {
7232
7243
  recipe: input.recipe,
7233
7244
  processEnv: input.processEnv,
7234
7245
  directory: input.directory,
7235
- program
7246
+ program,
7247
+ ...input.onSpawn === void 0 ? {} : { onSpawn: input.onSpawn }
7236
7248
  });
7237
7249
  }
7238
7250
  async function closeOpenCodeServer(handle) {
@@ -8778,9 +8790,31 @@ function createOpenCodeInstance(config, host, attachments) {
8778
8790
  const recipe = parseOpenCodeInstanceConfig(config);
8779
8791
  const events = new EventBus();
8780
8792
  const sessions = /* @__PURE__ */ new Map();
8793
+ const pendingServers = /* @__PURE__ */ new Map();
8794
+ const stops = /* @__PURE__ */ new WeakMap();
8795
+ const rememberPendingServer = (threadId, server) => {
8796
+ const pending = pendingServers.get(threadId) ?? /* @__PURE__ */ new Set();
8797
+ pending.add(server);
8798
+ pendingServers.set(threadId, pending);
8799
+ };
8800
+ const forgetPendingServer = (threadId, server) => {
8801
+ const pending = pendingServers.get(threadId);
8802
+ pending?.delete(server);
8803
+ if (pending?.size === 0) pendingServers.delete(threadId);
8804
+ };
8805
+ const closePendingServer = async (threadId, server) => {
8806
+ await closeOpenCodeServer(server);
8807
+ forgetPendingServer(threadId, server);
8808
+ };
8809
+ const closePendingServers = async (threadId) => {
8810
+ for (const server of [...pendingServers.get(threadId) ?? []]) {
8811
+ await closePendingServer(threadId, server);
8812
+ }
8813
+ };
8781
8814
  const declineRelay = makeDeclineReasonRelay();
8782
8815
  const boundInstanceId = host.instanceId;
8783
8816
  let disposed = false;
8817
+ let disposal;
8784
8818
  let textGeneration;
8785
8819
  const requireSession = (threadId) => {
8786
8820
  const context = sessions.get(threadId);
@@ -8800,28 +8834,38 @@ function createOpenCodeInstance(config, host, attachments) {
8800
8834
  await closeOpenCodeServer(context.server);
8801
8835
  };
8802
8836
  const stopContext = async (context, reason, message) => {
8803
- if (context.stopped) return;
8804
- context.stopped = true;
8805
- context.eventAbort.abort();
8837
+ const pending = stops.get(context);
8838
+ if (pending) return pending;
8839
+ const work = (async () => {
8840
+ context.stopped = true;
8841
+ context.eventAbort.abort();
8842
+ try {
8843
+ await context.client.session.abort({
8844
+ sessionID: context.sessionId,
8845
+ directory: context.directory
8846
+ });
8847
+ } catch {
8848
+ }
8849
+ await closeOpenCodeServer(context.server);
8850
+ await context.pump?.catch(() => void 0);
8851
+ await context.serverWatch?.catch(() => void 0);
8852
+ if (reason === "graceful") {
8853
+ emitEvent(events, context, "session.exited", {
8854
+ reason: message ?? "Session stopped.",
8855
+ recoverable: false,
8856
+ exitKind: "graceful"
8857
+ });
8858
+ context.session = { ...context.session, status: "stopped", updatedAt: nowIso() };
8859
+ } else {
8860
+ emitUnexpectedExit(events, context, new Error(message ?? "OpenCode session failed."));
8861
+ }
8862
+ })();
8863
+ stops.set(context, work);
8806
8864
  try {
8807
- await context.client.session.abort({
8808
- sessionID: context.sessionId,
8809
- directory: context.directory
8810
- });
8811
- } catch {
8812
- }
8813
- await closeOpenCodeServer(context.server);
8814
- await context.pump?.catch(() => void 0);
8815
- await context.serverWatch?.catch(() => void 0);
8816
- if (reason === "graceful") {
8817
- emitEvent(events, context, "session.exited", {
8818
- reason: message ?? "Session stopped.",
8819
- recoverable: false,
8820
- exitKind: "graceful"
8821
- });
8822
- context.session = { ...context.session, status: "stopped", updatedAt: nowIso() };
8823
- } else {
8824
- emitUnexpectedExit(events, context, new Error(message ?? "OpenCode session failed."));
8865
+ await work;
8866
+ } catch (cause) {
8867
+ stops.delete(context);
8868
+ throw cause;
8825
8869
  }
8826
8870
  };
8827
8871
  const instance = {
@@ -8837,65 +8881,85 @@ function createOpenCodeInstance(config, host, attachments) {
8837
8881
  await stopContext(existing, "graceful", "Replaced by a new session.");
8838
8882
  sessions.delete(input.threadId);
8839
8883
  }
8884
+ await closePendingServers(input.threadId);
8840
8885
  const directory = requireCwd(input, host);
8886
+ let startingServer;
8841
8887
  const server = await connectToOpenCodeServer({
8842
8888
  host,
8843
8889
  recipe,
8844
8890
  processEnv: input.launch.processEnv,
8845
8891
  directory,
8846
- program: recipe.binaryPath
8847
- });
8848
- const client2 = createOpenCodeSdkClient({
8849
- url: server.url,
8850
- directory,
8851
- password: server.password
8892
+ program: recipe.binaryPath,
8893
+ onSpawn: (resource) => {
8894
+ startingServer = resource;
8895
+ rememberPendingServer(input.threadId, resource);
8896
+ }
8852
8897
  });
8853
- const nativeModeId = openCodeNativeModeFor(input.runtimeMode, input.nativeModeId);
8854
- const permission = openCodePermissionRulesForNativeMode(nativeModeId);
8855
- const resume = input.discardResumeCursor === true ? void 0 : parseOpenCodeResume(input.resumeCursor);
8856
- let sessionId;
8857
- let createdSession = false;
8858
- const requestedTitle = input.title?.trim();
8859
- if (resume) {
8860
- try {
8861
- const existingSession = await client2.session.get({
8862
- sessionID: resume.sessionId,
8863
- directory
8864
- });
8865
- const info = existingSession.data;
8866
- if (!info) {
8867
- throw new Error("OpenCode session.get returned no data.");
8868
- }
8869
- const storedDirectory = info.directory ?? info.path ?? directory;
8870
- if (await isSameOpenCodeDirectory(storedDirectory, directory)) {
8871
- await client2.session.update({
8872
- sessionID: info.id,
8873
- directory,
8874
- permission
8875
- });
8876
- sessionId = info.id;
8877
- } else {
8878
- const forked = await client2.session.fork({
8879
- sessionID: info.id,
8898
+ if (startingServer !== void 0) forgetPendingServer(input.threadId, startingServer);
8899
+ try {
8900
+ const client2 = createOpenCodeSdkClient({
8901
+ url: server.url,
8902
+ directory,
8903
+ password: server.password
8904
+ });
8905
+ const nativeModeId = openCodeNativeModeFor(input.runtimeMode, input.nativeModeId);
8906
+ const permission = openCodePermissionRulesForNativeMode(nativeModeId);
8907
+ const resume = input.discardResumeCursor === true ? void 0 : parseOpenCodeResume(input.resumeCursor);
8908
+ let sessionId;
8909
+ let createdSession = false;
8910
+ const requestedTitle = input.title?.trim();
8911
+ if (resume) {
8912
+ try {
8913
+ const existingSession = await client2.session.get({
8914
+ sessionID: resume.sessionId,
8880
8915
  directory
8881
8916
  });
8882
- const forkedInfo = forked.data;
8883
- if (!forkedInfo) {
8884
- throw new Error("OpenCode session.fork returned no data.");
8917
+ const info = existingSession.data;
8918
+ if (!info) {
8919
+ throw new Error("OpenCode session.get returned no data.");
8920
+ }
8921
+ const storedDirectory = info.directory ?? info.path ?? directory;
8922
+ if (await isSameOpenCodeDirectory(storedDirectory, directory)) {
8923
+ await client2.session.update({
8924
+ sessionID: info.id,
8925
+ directory,
8926
+ permission
8927
+ });
8928
+ sessionId = info.id;
8929
+ } else {
8930
+ const forked = await client2.session.fork({
8931
+ sessionID: info.id,
8932
+ directory
8933
+ });
8934
+ const forkedInfo = forked.data;
8935
+ if (!forkedInfo) {
8936
+ throw new Error("OpenCode session.fork returned no data.");
8937
+ }
8938
+ await client2.session.update({
8939
+ sessionID: forkedInfo.id,
8940
+ directory,
8941
+ permission
8942
+ });
8943
+ sessionId = forkedInfo.id;
8944
+ createdSession = true;
8945
+ }
8946
+ } catch (cause) {
8947
+ if (!isOpenCodeNotFound(cause)) {
8948
+ throw cause;
8885
8949
  }
8886
- await client2.session.update({
8887
- sessionID: forkedInfo.id,
8950
+ const created = await client2.session.create({
8888
8951
  directory,
8889
- permission
8952
+ permission,
8953
+ ...requestedTitle ? { title: requestedTitle } : {}
8890
8954
  });
8891
- sessionId = forkedInfo.id;
8955
+ const info = created.data;
8956
+ if (!info) {
8957
+ throw new Error("OpenCode session.create returned no data.", { cause });
8958
+ }
8959
+ sessionId = info.id;
8892
8960
  createdSession = true;
8893
8961
  }
8894
- } catch (cause) {
8895
- if (!isOpenCodeNotFound(cause)) {
8896
- await closeOpenCodeServer(server);
8897
- throw cause;
8898
- }
8962
+ } else {
8899
8963
  const created = await client2.session.create({
8900
8964
  directory,
8901
8965
  permission,
@@ -8903,90 +8967,80 @@ function createOpenCodeInstance(config, host, attachments) {
8903
8967
  });
8904
8968
  const info = created.data;
8905
8969
  if (!info) {
8906
- await closeOpenCodeServer(server);
8907
- throw new Error("OpenCode session.create returned no data.", { cause });
8970
+ throw new Error("OpenCode session.create returned no data.");
8908
8971
  }
8909
8972
  sessionId = info.id;
8910
8973
  createdSession = true;
8911
8974
  }
8912
- } else {
8913
- const created = await client2.session.create({
8975
+ const createdAt = nowIso();
8976
+ const resumeCursor = makeOpenCodeResumeCursor(sessionId);
8977
+ const initialModel = modelIdFromSelection(input.modelSelection) ?? readString2(input.modelSelection?.model);
8978
+ const session = {
8979
+ provider: OPENCODE_DRIVER_KIND,
8980
+ providerInstanceId: boundInstanceId,
8981
+ status: "ready",
8982
+ runtimeMode: input.runtimeMode,
8983
+ nativeModeId,
8984
+ cwd: directory,
8985
+ threadId: input.threadId,
8986
+ resumeCursor,
8987
+ createdAt,
8988
+ updatedAt: createdAt,
8989
+ ...initialModel ? { model: initialModel } : {}
8990
+ };
8991
+ const context = {
8992
+ threadId: input.threadId,
8993
+ session,
8994
+ sessionId,
8914
8995
  directory,
8915
- permission,
8916
- ...requestedTitle ? { title: requestedTitle } : {}
8917
- });
8918
- const info = created.data;
8919
- if (!info) {
8920
- await closeOpenCodeServer(server);
8921
- throw new Error("OpenCode session.create returned no data.");
8922
- }
8923
- sessionId = info.id;
8924
- createdSession = true;
8925
- }
8926
- const createdAt = nowIso();
8927
- const resumeCursor = makeOpenCodeResumeCursor(sessionId);
8928
- const initialModel = modelIdFromSelection(input.modelSelection) ?? readString2(input.modelSelection?.model);
8929
- const session = {
8930
- provider: OPENCODE_DRIVER_KIND,
8931
- providerInstanceId: boundInstanceId,
8932
- status: "ready",
8933
- runtimeMode: input.runtimeMode,
8934
- nativeModeId,
8935
- cwd: directory,
8936
- threadId: input.threadId,
8937
- resumeCursor,
8938
- createdAt,
8939
- updatedAt: createdAt,
8940
- ...initialModel ? { model: initialModel } : {}
8941
- };
8942
- const context = {
8943
- threadId: input.threadId,
8944
- session,
8945
- sessionId,
8946
- directory,
8947
- client: client2,
8948
- server,
8949
- createdSession,
8950
- eventAbort: new AbortController(),
8951
- pump: void 0,
8952
- serverWatch: void 0,
8953
- stopped: false,
8954
- pendingPermissions: /* @__PURE__ */ new Map(),
8955
- pendingQuestions: /* @__PURE__ */ new Map(),
8956
- declineReasons: /* @__PURE__ */ new Map(),
8957
- usageByMessageId: /* @__PURE__ */ new Map(),
8958
- messageRoleById: /* @__PURE__ */ new Map(),
8959
- assistantTextByPartId: /* @__PURE__ */ new Map(),
8960
- partTypeById: /* @__PURE__ */ new Map(),
8961
- completedTextParts: /* @__PURE__ */ new Set(),
8962
- startedToolItems: /* @__PURE__ */ new Set(),
8963
- compaction: void 0,
8964
- attachmentsApi: attachments,
8965
- runtimeMode: input.runtimeMode,
8966
- boundModelId: input.launch.requestedModelId?.trim() || void 0,
8967
- matchModel: createCatalogModelMatcher2(host.log)
8968
- };
8969
- const winner = sessions.get(input.threadId);
8970
- if (winner) {
8971
- if (createdSession) {
8972
- await abortCreatedSession(context);
8973
- } else {
8974
- context.eventAbort.abort();
8975
- await closeOpenCodeServer(server);
8996
+ client: client2,
8997
+ server,
8998
+ createdSession,
8999
+ eventAbort: new AbortController(),
9000
+ pump: void 0,
9001
+ serverWatch: void 0,
9002
+ stopped: false,
9003
+ pendingPermissions: /* @__PURE__ */ new Map(),
9004
+ pendingQuestions: /* @__PURE__ */ new Map(),
9005
+ declineReasons: /* @__PURE__ */ new Map(),
9006
+ usageByMessageId: /* @__PURE__ */ new Map(),
9007
+ messageRoleById: /* @__PURE__ */ new Map(),
9008
+ assistantTextByPartId: /* @__PURE__ */ new Map(),
9009
+ partTypeById: /* @__PURE__ */ new Map(),
9010
+ completedTextParts: /* @__PURE__ */ new Set(),
9011
+ startedToolItems: /* @__PURE__ */ new Set(),
9012
+ compaction: void 0,
9013
+ attachmentsApi: attachments,
9014
+ runtimeMode: input.runtimeMode,
9015
+ boundModelId: input.launch.requestedModelId?.trim() || void 0,
9016
+ matchModel: createCatalogModelMatcher2(host.log)
9017
+ };
9018
+ const winner = sessions.get(input.threadId);
9019
+ if (winner) {
9020
+ if (createdSession) {
9021
+ await abortCreatedSession(context);
9022
+ } else {
9023
+ context.eventAbort.abort();
9024
+ await closeOpenCodeServer(server);
9025
+ }
9026
+ return sessionFromContext(winner);
8976
9027
  }
8977
- return sessionFromContext(winner);
9028
+ sessions.set(input.threadId, context);
9029
+ emitEvent(
9030
+ events,
9031
+ context,
9032
+ "session.started",
9033
+ input.resumeCursor !== void 0 ? { resume: input.resumeCursor } : {}
9034
+ );
9035
+ emitEvent(events, context, "thread.started", { providerThreadId: sessionId });
9036
+ emitEvent(events, context, "session.state.changed", { state: "ready" });
9037
+ startEventPump({ events, context, declineRelay });
9038
+ return sessionFromContext(context);
9039
+ } catch (cause) {
9040
+ rememberPendingServer(input.threadId, server);
9041
+ await closePendingServer(input.threadId, server);
9042
+ throw cause;
8978
9043
  }
8979
- sessions.set(input.threadId, context);
8980
- emitEvent(
8981
- events,
8982
- context,
8983
- "session.started",
8984
- input.resumeCursor !== void 0 ? { resume: input.resumeCursor } : {}
8985
- );
8986
- emitEvent(events, context, "thread.started", { providerThreadId: sessionId });
8987
- emitEvent(events, context, "session.state.changed", { state: "ready" });
8988
- startEventPump({ events, context, declineRelay });
8989
- return sessionFromContext(context);
8990
9044
  },
8991
9045
  sendTurn: async (input) => {
8992
9046
  const context = requireSession(input.threadId);
@@ -9137,13 +9191,11 @@ function createOpenCodeInstance(config, host, attachments) {
9137
9191
  },
9138
9192
  stopSession: async (threadId) => {
9139
9193
  const context = sessions.get(threadId);
9140
- if (!context) throw new Error(`unknown thread ${threadId}`);
9141
- sessions.delete(threadId);
9142
- try {
9194
+ if (context) {
9143
9195
  await stopContext(context, "graceful");
9144
- } catch {
9145
- sessions.delete(threadId);
9196
+ if (sessions.get(threadId) === context) sessions.delete(threadId);
9146
9197
  }
9198
+ await closePendingServers(threadId);
9147
9199
  },
9148
9200
  readThread: async (threadId) => {
9149
9201
  const context = requireSession(threadId);
@@ -9166,14 +9218,20 @@ function createOpenCodeInstance(config, host, attachments) {
9166
9218
  events,
9167
9219
  continuationKey: makeOpenCodeContinuationGroupKey(recipe),
9168
9220
  dispose: async () => {
9169
- if (disposed) return;
9221
+ if (disposal) return disposal;
9170
9222
  disposed = true;
9171
- const remaining = [...sessions.values()];
9172
- sessions.clear();
9173
- await Promise.all(
9174
- remaining.map((context) => stopContext(context, "graceful", "Instance disposed."))
9175
- );
9176
- events.close();
9223
+ const work = (async () => {
9224
+ const remaining = /* @__PURE__ */ new Set([...sessions.keys(), ...pendingServers.keys()]);
9225
+ await Promise.all([...remaining].map((threadId) => instance.stopSession(threadId)));
9226
+ events.close();
9227
+ })();
9228
+ disposal = work;
9229
+ try {
9230
+ await work;
9231
+ } catch (cause) {
9232
+ disposal = void 0;
9233
+ throw cause;
9234
+ }
9177
9235
  },
9178
9236
  get textGeneration() {
9179
9237
  textGeneration ??= createOpenCodeTextGeneration(recipe, host);
package/package.json CHANGED
@@ -1,6 +1,6 @@
1
1
  {
2
2
  "name": "@ycodium-ai/agent-opencode",
3
- "version": "0.2.2167",
3
+ "version": "0.2.2169",
4
4
  "description": "OpenCode executor: OpenCode CLI via @opencode-ai/sdk/v2.",
5
5
  "keywords": [
6
6
  "ycodium",
@@ -23,7 +23,7 @@
23
23
  "@types/node": "24.12.4",
24
24
  "esbuild": "0.28.1",
25
25
  "vite-plus": "0.2.2",
26
- "@ycodium-ai/plugin-api": "0.2.2167"
26
+ "@ycodium-ai/plugin-api": "0.2.2169"
27
27
  },
28
28
  "ycodium": {
29
29
  "plugin": "./dist/index.js",