@k-leumas/queque-cli 0.6.1 → 0.7.0
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.
- package/README.md +43 -10
- package/dist/cli/app.js +1376 -150
- package/dist/cli/app.js.map +1 -1
- package/package.json +1 -1
package/dist/cli/app.js
CHANGED
|
@@ -270,7 +270,7 @@ var sleep;
|
|
|
270
270
|
var init_sleep = __esm({
|
|
271
271
|
"node_modules/.pnpm/@anthropic-ai+sdk@0.92.0_zod@4.1.5/node_modules/@anthropic-ai/sdk/internal/utils/sleep.mjs"() {
|
|
272
272
|
"use strict";
|
|
273
|
-
sleep = (ms) => new Promise((
|
|
273
|
+
sleep = (ms) => new Promise((resolve5) => setTimeout(resolve5, ms));
|
|
274
274
|
}
|
|
275
275
|
});
|
|
276
276
|
|
|
@@ -1059,8 +1059,8 @@ var init_api_promise = __esm({
|
|
|
1059
1059
|
init_parse();
|
|
1060
1060
|
APIPromise = class _APIPromise extends Promise {
|
|
1061
1061
|
constructor(client, responsePromise, parseResponse = defaultParseResponse) {
|
|
1062
|
-
super((
|
|
1063
|
-
|
|
1062
|
+
super((resolve5) => {
|
|
1063
|
+
resolve5(null);
|
|
1064
1064
|
});
|
|
1065
1065
|
this.responsePromise = responsePromise;
|
|
1066
1066
|
this.parseResponse = parseResponse;
|
|
@@ -3242,12 +3242,12 @@ var init_BetaMessageStream = __esm({
|
|
|
3242
3242
|
}
|
|
3243
3243
|
return this._emit("error", new AnthropicError(String(error43)));
|
|
3244
3244
|
});
|
|
3245
|
-
__classPrivateFieldSet(this, _BetaMessageStream_connectedPromise, new Promise((
|
|
3246
|
-
__classPrivateFieldSet(this, _BetaMessageStream_resolveConnectedPromise,
|
|
3245
|
+
__classPrivateFieldSet(this, _BetaMessageStream_connectedPromise, new Promise((resolve5, reject) => {
|
|
3246
|
+
__classPrivateFieldSet(this, _BetaMessageStream_resolveConnectedPromise, resolve5, "f");
|
|
3247
3247
|
__classPrivateFieldSet(this, _BetaMessageStream_rejectConnectedPromise, reject, "f");
|
|
3248
3248
|
}), "f");
|
|
3249
|
-
__classPrivateFieldSet(this, _BetaMessageStream_endPromise, new Promise((
|
|
3250
|
-
__classPrivateFieldSet(this, _BetaMessageStream_resolveEndPromise,
|
|
3249
|
+
__classPrivateFieldSet(this, _BetaMessageStream_endPromise, new Promise((resolve5, reject) => {
|
|
3250
|
+
__classPrivateFieldSet(this, _BetaMessageStream_resolveEndPromise, resolve5, "f");
|
|
3251
3251
|
__classPrivateFieldSet(this, _BetaMessageStream_rejectEndPromise, reject, "f");
|
|
3252
3252
|
}), "f");
|
|
3253
3253
|
__classPrivateFieldGet(this, _BetaMessageStream_connectedPromise, "f").catch(() => {
|
|
@@ -3417,11 +3417,11 @@ var init_BetaMessageStream = __esm({
|
|
|
3417
3417
|
* const message = await stream.emitted('message') // rejects if the stream errors
|
|
3418
3418
|
*/
|
|
3419
3419
|
emitted(event) {
|
|
3420
|
-
return new Promise((
|
|
3420
|
+
return new Promise((resolve5, reject) => {
|
|
3421
3421
|
__classPrivateFieldSet(this, _BetaMessageStream_catchingPromiseCreated, true, "f");
|
|
3422
3422
|
if (event !== "error")
|
|
3423
3423
|
this.once("error", reject);
|
|
3424
|
-
this.once(event,
|
|
3424
|
+
this.once(event, resolve5);
|
|
3425
3425
|
});
|
|
3426
3426
|
}
|
|
3427
3427
|
async done() {
|
|
@@ -3764,7 +3764,7 @@ var init_BetaMessageStream = __esm({
|
|
|
3764
3764
|
if (done) {
|
|
3765
3765
|
return { value: void 0, done: true };
|
|
3766
3766
|
}
|
|
3767
|
-
return new Promise((
|
|
3767
|
+
return new Promise((resolve5, reject) => readQueue.push({ resolve: resolve5, reject })).then((chunk2) => chunk2 ? { value: chunk2, done: false } : { value: void 0, done: true });
|
|
3768
3768
|
}
|
|
3769
3769
|
const chunk = pushQueue.shift();
|
|
3770
3770
|
return { value: chunk, done: false };
|
|
@@ -3837,13 +3837,13 @@ Wrap your summary in <summary></summary> tags.`;
|
|
|
3837
3837
|
|
|
3838
3838
|
// node_modules/.pnpm/@anthropic-ai+sdk@0.92.0_zod@4.1.5/node_modules/@anthropic-ai/sdk/lib/tools/BetaToolRunner.mjs
|
|
3839
3839
|
function promiseWithResolvers() {
|
|
3840
|
-
let
|
|
3840
|
+
let resolve5;
|
|
3841
3841
|
let reject;
|
|
3842
3842
|
const promise2 = new Promise((res, rej) => {
|
|
3843
|
-
|
|
3843
|
+
resolve5 = res;
|
|
3844
3844
|
reject = rej;
|
|
3845
3845
|
});
|
|
3846
|
-
return { promise: promise2, resolve:
|
|
3846
|
+
return { promise: promise2, resolve: resolve5, reject };
|
|
3847
3847
|
}
|
|
3848
3848
|
async function generateToolResponse(params, lastMessage = params.messages.at(-1), requestOptions) {
|
|
3849
3849
|
if (!lastMessage || lastMessage.role !== "assistant" || !lastMessage.content || typeof lastMessage.content === "string") {
|
|
@@ -4768,9 +4768,9 @@ var init_versions2 = __esm({
|
|
|
4768
4768
|
* );
|
|
4769
4769
|
* ```
|
|
4770
4770
|
*/
|
|
4771
|
-
retrieve(
|
|
4771
|
+
retrieve(version3, params, options) {
|
|
4772
4772
|
const { skill_id, betas } = params;
|
|
4773
|
-
return this._client.get(path`/v1/skills/${skill_id}/versions/${
|
|
4773
|
+
return this._client.get(path`/v1/skills/${skill_id}/versions/${version3}?beta=true`, {
|
|
4774
4774
|
...options,
|
|
4775
4775
|
headers: buildHeaders([
|
|
4776
4776
|
{ "anthropic-beta": [...betas ?? [], "skills-2025-10-02"].toString() },
|
|
@@ -4813,9 +4813,9 @@ var init_versions2 = __esm({
|
|
|
4813
4813
|
* );
|
|
4814
4814
|
* ```
|
|
4815
4815
|
*/
|
|
4816
|
-
delete(
|
|
4816
|
+
delete(version3, params, options) {
|
|
4817
4817
|
const { skill_id, betas } = params;
|
|
4818
|
-
return this._client.delete(path`/v1/skills/${skill_id}/versions/${
|
|
4818
|
+
return this._client.delete(path`/v1/skills/${skill_id}/versions/${version3}?beta=true`, {
|
|
4819
4819
|
...options,
|
|
4820
4820
|
headers: buildHeaders([
|
|
4821
4821
|
{ "anthropic-beta": [...betas ?? [], "skills-2025-10-02"].toString() },
|
|
@@ -5441,12 +5441,12 @@ var init_MessageStream = __esm({
|
|
|
5441
5441
|
}
|
|
5442
5442
|
return this._emit("error", new AnthropicError(String(error43)));
|
|
5443
5443
|
});
|
|
5444
|
-
__classPrivateFieldSet(this, _MessageStream_connectedPromise, new Promise((
|
|
5445
|
-
__classPrivateFieldSet(this, _MessageStream_resolveConnectedPromise,
|
|
5444
|
+
__classPrivateFieldSet(this, _MessageStream_connectedPromise, new Promise((resolve5, reject) => {
|
|
5445
|
+
__classPrivateFieldSet(this, _MessageStream_resolveConnectedPromise, resolve5, "f");
|
|
5446
5446
|
__classPrivateFieldSet(this, _MessageStream_rejectConnectedPromise, reject, "f");
|
|
5447
5447
|
}), "f");
|
|
5448
|
-
__classPrivateFieldSet(this, _MessageStream_endPromise, new Promise((
|
|
5449
|
-
__classPrivateFieldSet(this, _MessageStream_resolveEndPromise,
|
|
5448
|
+
__classPrivateFieldSet(this, _MessageStream_endPromise, new Promise((resolve5, reject) => {
|
|
5449
|
+
__classPrivateFieldSet(this, _MessageStream_resolveEndPromise, resolve5, "f");
|
|
5450
5450
|
__classPrivateFieldSet(this, _MessageStream_rejectEndPromise, reject, "f");
|
|
5451
5451
|
}), "f");
|
|
5452
5452
|
__classPrivateFieldGet(this, _MessageStream_connectedPromise, "f").catch(() => {
|
|
@@ -5616,11 +5616,11 @@ var init_MessageStream = __esm({
|
|
|
5616
5616
|
* const message = await stream.emitted('message') // rejects if the stream errors
|
|
5617
5617
|
*/
|
|
5618
5618
|
emitted(event) {
|
|
5619
|
-
return new Promise((
|
|
5619
|
+
return new Promise((resolve5, reject) => {
|
|
5620
5620
|
__classPrivateFieldSet(this, _MessageStream_catchingPromiseCreated, true, "f");
|
|
5621
5621
|
if (event !== "error")
|
|
5622
5622
|
this.once("error", reject);
|
|
5623
|
-
this.once(event,
|
|
5623
|
+
this.once(event, resolve5);
|
|
5624
5624
|
});
|
|
5625
5625
|
}
|
|
5626
5626
|
async done() {
|
|
@@ -5938,7 +5938,7 @@ var init_MessageStream = __esm({
|
|
|
5938
5938
|
if (done) {
|
|
5939
5939
|
return { value: void 0, done: true };
|
|
5940
5940
|
}
|
|
5941
|
-
return new Promise((
|
|
5941
|
+
return new Promise((resolve5, reject) => readQueue.push({ resolve: resolve5, reject })).then((chunk2) => chunk2 ? { value: chunk2, done: false } : { value: void 0, done: true });
|
|
5942
5942
|
}
|
|
5943
5943
|
const chunk = pushQueue.shift();
|
|
5944
5944
|
return { value: chunk, done: false };
|
|
@@ -7727,21 +7727,21 @@ var require_react_development = __commonJS({
|
|
|
7727
7727
|
);
|
|
7728
7728
|
actScopeDepth = prevActScopeDepth;
|
|
7729
7729
|
}
|
|
7730
|
-
function recursivelyFlushAsyncActWork(returnValue,
|
|
7730
|
+
function recursivelyFlushAsyncActWork(returnValue, resolve5, reject) {
|
|
7731
7731
|
var queue = ReactSharedInternals.actQueue;
|
|
7732
7732
|
if (null !== queue)
|
|
7733
7733
|
if (0 !== queue.length)
|
|
7734
7734
|
try {
|
|
7735
7735
|
flushActQueue(queue);
|
|
7736
7736
|
enqueueTask(function() {
|
|
7737
|
-
return recursivelyFlushAsyncActWork(returnValue,
|
|
7737
|
+
return recursivelyFlushAsyncActWork(returnValue, resolve5, reject);
|
|
7738
7738
|
});
|
|
7739
7739
|
return;
|
|
7740
7740
|
} catch (error43) {
|
|
7741
7741
|
ReactSharedInternals.thrownErrors.push(error43);
|
|
7742
7742
|
}
|
|
7743
7743
|
else ReactSharedInternals.actQueue = null;
|
|
7744
|
-
0 < ReactSharedInternals.thrownErrors.length ? (queue = aggregateErrors(ReactSharedInternals.thrownErrors), ReactSharedInternals.thrownErrors.length = 0, reject(queue)) :
|
|
7744
|
+
0 < ReactSharedInternals.thrownErrors.length ? (queue = aggregateErrors(ReactSharedInternals.thrownErrors), ReactSharedInternals.thrownErrors.length = 0, reject(queue)) : resolve5(returnValue);
|
|
7745
7745
|
}
|
|
7746
7746
|
function flushActQueue(queue) {
|
|
7747
7747
|
if (!isFlushing) {
|
|
@@ -7928,7 +7928,7 @@ var require_react_development = __commonJS({
|
|
|
7928
7928
|
));
|
|
7929
7929
|
});
|
|
7930
7930
|
return {
|
|
7931
|
-
then: function(
|
|
7931
|
+
then: function(resolve5, reject) {
|
|
7932
7932
|
didAwaitActCall = true;
|
|
7933
7933
|
thenable.then(
|
|
7934
7934
|
function(returnValue) {
|
|
@@ -7938,7 +7938,7 @@ var require_react_development = __commonJS({
|
|
|
7938
7938
|
flushActQueue(queue), enqueueTask(function() {
|
|
7939
7939
|
return recursivelyFlushAsyncActWork(
|
|
7940
7940
|
returnValue,
|
|
7941
|
-
|
|
7941
|
+
resolve5,
|
|
7942
7942
|
reject
|
|
7943
7943
|
);
|
|
7944
7944
|
});
|
|
@@ -7952,7 +7952,7 @@ var require_react_development = __commonJS({
|
|
|
7952
7952
|
ReactSharedInternals.thrownErrors.length = 0;
|
|
7953
7953
|
reject(_thrownError);
|
|
7954
7954
|
}
|
|
7955
|
-
} else
|
|
7955
|
+
} else resolve5(returnValue);
|
|
7956
7956
|
},
|
|
7957
7957
|
function(error43) {
|
|
7958
7958
|
popActScope(prevActQueue, prevActScopeDepth);
|
|
@@ -7974,15 +7974,15 @@ var require_react_development = __commonJS({
|
|
|
7974
7974
|
if (0 < ReactSharedInternals.thrownErrors.length)
|
|
7975
7975
|
throw callback = aggregateErrors(ReactSharedInternals.thrownErrors), ReactSharedInternals.thrownErrors.length = 0, callback;
|
|
7976
7976
|
return {
|
|
7977
|
-
then: function(
|
|
7977
|
+
then: function(resolve5, reject) {
|
|
7978
7978
|
didAwaitActCall = true;
|
|
7979
7979
|
0 === prevActScopeDepth ? (ReactSharedInternals.actQueue = queue, enqueueTask(function() {
|
|
7980
7980
|
return recursivelyFlushAsyncActWork(
|
|
7981
7981
|
returnValue$jscomp$0,
|
|
7982
|
-
|
|
7982
|
+
resolve5,
|
|
7983
7983
|
reject
|
|
7984
7984
|
);
|
|
7985
|
-
})) :
|
|
7985
|
+
})) : resolve5(returnValue$jscomp$0);
|
|
7986
7986
|
}
|
|
7987
7987
|
};
|
|
7988
7988
|
};
|
|
@@ -10066,8 +10066,8 @@ var require_react_reconciler_production = __commonJS({
|
|
|
10066
10066
|
currentEntangledActionThenable = {
|
|
10067
10067
|
status: "pending",
|
|
10068
10068
|
value: void 0,
|
|
10069
|
-
then: function(
|
|
10070
|
-
entangledListeners.push(
|
|
10069
|
+
then: function(resolve5) {
|
|
10070
|
+
entangledListeners.push(resolve5);
|
|
10071
10071
|
}
|
|
10072
10072
|
};
|
|
10073
10073
|
}
|
|
@@ -10090,8 +10090,8 @@ var require_react_reconciler_production = __commonJS({
|
|
|
10090
10090
|
status: "pending",
|
|
10091
10091
|
value: null,
|
|
10092
10092
|
reason: null,
|
|
10093
|
-
then: function(
|
|
10094
|
-
listeners.push(
|
|
10093
|
+
then: function(resolve5) {
|
|
10094
|
+
listeners.push(resolve5);
|
|
10095
10095
|
}
|
|
10096
10096
|
};
|
|
10097
10097
|
thenable.then(
|
|
@@ -19690,8 +19690,8 @@ var require_react_reconciler_development = __commonJS({
|
|
|
19690
19690
|
currentEntangledActionThenable = {
|
|
19691
19691
|
status: "pending",
|
|
19692
19692
|
value: void 0,
|
|
19693
|
-
then: function(
|
|
19694
|
-
entangledListeners.push(
|
|
19693
|
+
then: function(resolve5) {
|
|
19694
|
+
entangledListeners.push(resolve5);
|
|
19695
19695
|
}
|
|
19696
19696
|
};
|
|
19697
19697
|
}
|
|
@@ -19714,8 +19714,8 @@ var require_react_reconciler_development = __commonJS({
|
|
|
19714
19714
|
status: "pending",
|
|
19715
19715
|
value: null,
|
|
19716
19716
|
reason: null,
|
|
19717
|
-
then: function(
|
|
19718
|
-
listeners.push(
|
|
19717
|
+
then: function(resolve5) {
|
|
19718
|
+
listeners.push(resolve5);
|
|
19719
19719
|
}
|
|
19720
19720
|
};
|
|
19721
19721
|
thenable.then(
|
|
@@ -32344,14 +32344,14 @@ var require_receiver = __commonJS({
|
|
|
32344
32344
|
* @return {(Error|RangeError)} The error
|
|
32345
32345
|
* @private
|
|
32346
32346
|
*/
|
|
32347
|
-
createError(ErrorCtor, message, prefix, statusCode,
|
|
32347
|
+
createError(ErrorCtor, message, prefix, statusCode, errorCode2) {
|
|
32348
32348
|
this._loop = false;
|
|
32349
32349
|
this._errored = true;
|
|
32350
32350
|
const err = new ErrorCtor(
|
|
32351
32351
|
prefix ? `Invalid WebSocket frame: ${message}` : message
|
|
32352
32352
|
);
|
|
32353
32353
|
Error.captureStackTrace(err, this.createError);
|
|
32354
|
-
err.code =
|
|
32354
|
+
err.code = errorCode2;
|
|
32355
32355
|
err[kStatusCode] = statusCode;
|
|
32356
32356
|
return err;
|
|
32357
32357
|
}
|
|
@@ -33239,7 +33239,7 @@ var require_websocket = __commonJS({
|
|
|
33239
33239
|
var http = __require("http");
|
|
33240
33240
|
var net4 = __require("net");
|
|
33241
33241
|
var tls = __require("tls");
|
|
33242
|
-
var { randomBytes, createHash: createHash2 } = __require("crypto");
|
|
33242
|
+
var { randomBytes: randomBytes2, createHash: createHash2 } = __require("crypto");
|
|
33243
33243
|
var { Duplex, Readable } = __require("stream");
|
|
33244
33244
|
var { URL: URL2 } = __require("url");
|
|
33245
33245
|
var PerMessageDeflate2 = require_permessage_deflate();
|
|
@@ -33769,7 +33769,7 @@ var require_websocket = __commonJS({
|
|
|
33769
33769
|
}
|
|
33770
33770
|
}
|
|
33771
33771
|
const defaultPort = isSecure ? 443 : 80;
|
|
33772
|
-
const key =
|
|
33772
|
+
const key = randomBytes2(16).toString("base64");
|
|
33773
33773
|
const request = isSecure ? https.request : http.request;
|
|
33774
33774
|
const protocolSet = /* @__PURE__ */ new Set();
|
|
33775
33775
|
let perMessageDeflate;
|
|
@@ -34461,7 +34461,7 @@ var require_websocket_server = __commonJS({
|
|
|
34461
34461
|
socket.on("error", socketOnError);
|
|
34462
34462
|
const key = req.headers["sec-websocket-key"];
|
|
34463
34463
|
const upgrade = req.headers.upgrade;
|
|
34464
|
-
const
|
|
34464
|
+
const version3 = +req.headers["sec-websocket-version"];
|
|
34465
34465
|
if (req.method !== "GET") {
|
|
34466
34466
|
const message = "Invalid HTTP method";
|
|
34467
34467
|
abortHandshakeOrEmitwsClientError(this, req, socket, 405, message);
|
|
@@ -34477,7 +34477,7 @@ var require_websocket_server = __commonJS({
|
|
|
34477
34477
|
abortHandshakeOrEmitwsClientError(this, req, socket, 400, message);
|
|
34478
34478
|
return;
|
|
34479
34479
|
}
|
|
34480
|
-
if (
|
|
34480
|
+
if (version3 !== 13 && version3 !== 8) {
|
|
34481
34481
|
const message = "Missing or invalid Sec-WebSocket-Version header";
|
|
34482
34482
|
abortHandshakeOrEmitwsClientError(this, req, socket, 400, message, {
|
|
34483
34483
|
"Sec-WebSocket-Version": "13, 8"
|
|
@@ -34521,7 +34521,7 @@ var require_websocket_server = __commonJS({
|
|
|
34521
34521
|
}
|
|
34522
34522
|
if (this.options.verifyClient) {
|
|
34523
34523
|
const info = {
|
|
34524
|
-
origin: req.headers[`${
|
|
34524
|
+
origin: req.headers[`${version3 === 8 ? "sec-websocket-origin" : "origin"}`],
|
|
34525
34525
|
secure: !!(req.socket.authorized || req.socket.encrypted),
|
|
34526
34526
|
req
|
|
34527
34527
|
};
|
|
@@ -34757,22 +34757,22 @@ var init_devtools = __esm({
|
|
|
34757
34757
|
init_devtools_window_polyfill();
|
|
34758
34758
|
init_wrapper();
|
|
34759
34759
|
init_react_devtools_core();
|
|
34760
|
-
isDevToolsReachable = async () => new Promise((
|
|
34760
|
+
isDevToolsReachable = async () => new Promise((resolve5) => {
|
|
34761
34761
|
const socket = new wrapper_default("ws://localhost:8097");
|
|
34762
34762
|
const timeout = setTimeout(() => {
|
|
34763
34763
|
socket.terminate();
|
|
34764
|
-
|
|
34764
|
+
resolve5(false);
|
|
34765
34765
|
}, 2e3);
|
|
34766
34766
|
timeout.unref();
|
|
34767
34767
|
socket.on("open", () => {
|
|
34768
34768
|
clearTimeout(timeout);
|
|
34769
34769
|
socket.terminate();
|
|
34770
|
-
|
|
34770
|
+
resolve5(true);
|
|
34771
34771
|
});
|
|
34772
34772
|
socket.on("error", () => {
|
|
34773
34773
|
clearTimeout(timeout);
|
|
34774
34774
|
socket.terminate();
|
|
34775
|
-
|
|
34775
|
+
resolve5(false);
|
|
34776
34776
|
});
|
|
34777
34777
|
});
|
|
34778
34778
|
if (await isDevToolsReachable()) {
|
|
@@ -35654,8 +35654,8 @@ var Command = class {
|
|
|
35654
35654
|
this.config.ignoreOptionDefaultValue = true;
|
|
35655
35655
|
return this;
|
|
35656
35656
|
}
|
|
35657
|
-
version(
|
|
35658
|
-
this.versionNumber =
|
|
35657
|
+
version(version3, customFlags = "-v, --version") {
|
|
35658
|
+
this.versionNumber = version3;
|
|
35659
35659
|
this.option(customFlags, "Display version number");
|
|
35660
35660
|
return this;
|
|
35661
35661
|
}
|
|
@@ -35871,8 +35871,8 @@ var CAC = class extends EventTarget {
|
|
|
35871
35871
|
* Show version number when `-v, --version` flags appear.
|
|
35872
35872
|
*
|
|
35873
35873
|
*/
|
|
35874
|
-
version(
|
|
35875
|
-
this.globalCommand.version(
|
|
35874
|
+
version(version3, customFlags = "-v, --version") {
|
|
35875
|
+
this.globalCommand.version(version3, customFlags);
|
|
35876
35876
|
this.showVersionOnExit = true;
|
|
35877
35877
|
return this;
|
|
35878
35878
|
}
|
|
@@ -36050,7 +36050,7 @@ import * as fsp from "fs/promises";
|
|
|
36050
36050
|
// src/shared/qq-config.ts
|
|
36051
36051
|
import { readFileSync } from "fs";
|
|
36052
36052
|
import { homedir } from "os";
|
|
36053
|
-
import { join } from "path";
|
|
36053
|
+
import { isAbsolute, join, resolve } from "path";
|
|
36054
36054
|
|
|
36055
36055
|
// node_modules/.pnpm/zod@4.1.5/node_modules/zod/v4/classic/external.js
|
|
36056
36056
|
var external_exports = {};
|
|
@@ -37544,10 +37544,10 @@ var nanoid = /^[a-zA-Z0-9_-]{21}$/;
|
|
|
37544
37544
|
var duration = /^P(?:(\d+W)|(?!.*W)(?=\d|T\d)(\d+Y)?(\d+M)?(\d+D)?(T(?=\d)(\d+H)?(\d+M)?(\d+([.,]\d+)?S)?)?)$/;
|
|
37545
37545
|
var extendedDuration = /^[-+]?P(?!$)(?:(?:[-+]?\d+Y)|(?:[-+]?\d+[.,]\d+Y$))?(?:(?:[-+]?\d+M)|(?:[-+]?\d+[.,]\d+M$))?(?:(?:[-+]?\d+W)|(?:[-+]?\d+[.,]\d+W$))?(?:(?:[-+]?\d+D)|(?:[-+]?\d+[.,]\d+D$))?(?:T(?=[\d+-])(?:(?:[-+]?\d+H)|(?:[-+]?\d+[.,]\d+H$))?(?:(?:[-+]?\d+M)|(?:[-+]?\d+[.,]\d+M$))?(?:[-+]?\d+(?:[.,]\d+)?S)?)??$/;
|
|
37546
37546
|
var guid = /^([0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{12})$/;
|
|
37547
|
-
var uuid = (
|
|
37548
|
-
if (!
|
|
37547
|
+
var uuid = (version3) => {
|
|
37548
|
+
if (!version3)
|
|
37549
37549
|
return /^([0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[1-8][0-9a-fA-F]{3}-[89abAB][0-9a-fA-F]{3}-[0-9a-fA-F]{12}|00000000-0000-0000-0000-000000000000|ffffffff-ffff-ffff-ffff-ffffffffffff)$/;
|
|
37550
|
-
return new RegExp(`^([0-9a-fA-F]{8}-[0-9a-fA-F]{4}-${
|
|
37550
|
+
return new RegExp(`^([0-9a-fA-F]{8}-[0-9a-fA-F]{4}-${version3}[0-9a-fA-F]{3}-[89abAB][0-9a-fA-F]{3}-[0-9a-fA-F]{12})$`);
|
|
37551
37551
|
};
|
|
37552
37552
|
var uuid4 = /* @__PURE__ */ uuid(4);
|
|
37553
37553
|
var uuid6 = /* @__PURE__ */ uuid(6);
|
|
@@ -48101,7 +48101,12 @@ var qqConfigFileSchema = external_exports.object({
|
|
|
48101
48101
|
});
|
|
48102
48102
|
var cachedConfig = null;
|
|
48103
48103
|
function defaultConfigPath() {
|
|
48104
|
-
|
|
48104
|
+
const override = process.env.QQ_CONFIG_FILE?.trim();
|
|
48105
|
+
if (!override) {
|
|
48106
|
+
return join(homedir(), ".config", "qq", "config.json");
|
|
48107
|
+
}
|
|
48108
|
+
const expanded = override.startsWith("~/") ? join(homedir(), override.slice(2)) : override;
|
|
48109
|
+
return isAbsolute(expanded) ? expanded : resolve(homedir(), expanded);
|
|
48105
48110
|
}
|
|
48106
48111
|
var MAX_PATTERN_LENGTH = 256;
|
|
48107
48112
|
function compilePatterns(patterns) {
|
|
@@ -48363,7 +48368,8 @@ var candidateListSchema = external_exports.array(commandCandidateSchema).min(1).
|
|
|
48363
48368
|
|
|
48364
48369
|
// src/shared/env-file.ts
|
|
48365
48370
|
import { existsSync, readFileSync as readFileSync2 } from "fs";
|
|
48366
|
-
import {
|
|
48371
|
+
import { homedir as homedir2 } from "os";
|
|
48372
|
+
import { dirname, join as join2, resolve as resolve2 } from "path";
|
|
48367
48373
|
function findUp(startDir, filename) {
|
|
48368
48374
|
let current2 = startDir;
|
|
48369
48375
|
while (true) {
|
|
@@ -48406,12 +48412,19 @@ function usableSecret(value) {
|
|
|
48406
48412
|
const trimmed = value.trim();
|
|
48407
48413
|
return trimmed === "" ? void 0 : trimmed;
|
|
48408
48414
|
}
|
|
48409
|
-
function
|
|
48415
|
+
function envFileFor(startDir) {
|
|
48416
|
+
if (resolve2(startDir) === resolve2(homedir2())) {
|
|
48417
|
+
const homeFile = join2(homedir2(), ".env.local");
|
|
48418
|
+
return existsSync(homeFile) ? homeFile : null;
|
|
48419
|
+
}
|
|
48420
|
+
return findUp(startDir, ".env.local");
|
|
48421
|
+
}
|
|
48422
|
+
function readEnvValueFromDotEnvLocal(key, startDir = homedir2()) {
|
|
48410
48423
|
const cacheKey = `${key}\0${startDir}`;
|
|
48411
48424
|
if (envCache.has(cacheKey)) {
|
|
48412
48425
|
return envCache.get(cacheKey) ?? null;
|
|
48413
48426
|
}
|
|
48414
|
-
const envPath =
|
|
48427
|
+
const envPath = envFileFor(startDir);
|
|
48415
48428
|
if (!envPath) {
|
|
48416
48429
|
envCache.set(cacheKey, null);
|
|
48417
48430
|
return null;
|
|
@@ -48521,6 +48534,33 @@ function abortError() {
|
|
|
48521
48534
|
function isNormalStopReason(stopReason) {
|
|
48522
48535
|
return stopReason === "end_turn" || stopReason === "stop_sequence";
|
|
48523
48536
|
}
|
|
48537
|
+
var UNPARSEABLE_RESPONSE_MESSAGE = "QueQue: response held no command candidates";
|
|
48538
|
+
var UNSAFE_TEXT_CHARS = new RegExp("[^\\P{Cc}\\t\\n]|\\p{Cf}", "gu");
|
|
48539
|
+
var UNSAFE_LINE_CHARS = /[\p{Cc}\p{Cf}]/u;
|
|
48540
|
+
var UNSAFE_LINE_CHARS_GLOBAL = new RegExp(UNSAFE_LINE_CHARS.source, "gu");
|
|
48541
|
+
function replaceUnsafeLineChars(text) {
|
|
48542
|
+
return text.replace(UNSAFE_LINE_CHARS_GLOBAL, " ");
|
|
48543
|
+
}
|
|
48544
|
+
function sanitizeCandidate(candidate) {
|
|
48545
|
+
const command = candidate.command.replace(UNSAFE_TEXT_CHARS, "").trim();
|
|
48546
|
+
if (command.length === 0) {
|
|
48547
|
+
return null;
|
|
48548
|
+
}
|
|
48549
|
+
return { command, explanation: candidate.explanation.replace(UNSAFE_TEXT_CHARS, "") };
|
|
48550
|
+
}
|
|
48551
|
+
function sanitizeCandidates(candidates) {
|
|
48552
|
+
return candidates.flatMap((candidate) => {
|
|
48553
|
+
const clean = sanitizeCandidate(candidate);
|
|
48554
|
+
return clean ? [clean] : [];
|
|
48555
|
+
});
|
|
48556
|
+
}
|
|
48557
|
+
function stripTerminalControls(candidates) {
|
|
48558
|
+
const cleaned = sanitizeCandidates(candidates);
|
|
48559
|
+
if (cleaned.length === 0) {
|
|
48560
|
+
throw new Error(UNPARSEABLE_RESPONSE_MESSAGE);
|
|
48561
|
+
}
|
|
48562
|
+
return cleaned;
|
|
48563
|
+
}
|
|
48524
48564
|
function isAbortError(error43) {
|
|
48525
48565
|
if (error43 === null || typeof error43 !== "object") {
|
|
48526
48566
|
return false;
|
|
@@ -48653,20 +48693,99 @@ function parseCandidates(text) {
|
|
|
48653
48693
|
function finalCandidateList(text, streamed, finishedNormally, logFields = {}) {
|
|
48654
48694
|
const strict = parseStrictCandidateList(text);
|
|
48655
48695
|
if (strict) {
|
|
48656
|
-
return strict;
|
|
48696
|
+
return sanitizedOrPlaceholder(strict);
|
|
48657
48697
|
}
|
|
48658
48698
|
if (streamed.length > 0) {
|
|
48659
|
-
return streamed;
|
|
48699
|
+
return sanitizedOrPlaceholder(streamed);
|
|
48660
48700
|
}
|
|
48661
48701
|
if (!finishedNormally) {
|
|
48662
|
-
const complete = completeCandidates(text);
|
|
48702
|
+
const complete = sanitizeCandidates(completeCandidates(text));
|
|
48663
48703
|
if (complete.length === 0) {
|
|
48664
48704
|
void appendDebugLog("provider", "response truncated", logFields);
|
|
48665
48705
|
throw new Error(TRUNCATED_RESPONSE_MESSAGE);
|
|
48666
48706
|
}
|
|
48667
48707
|
return complete;
|
|
48668
48708
|
}
|
|
48669
|
-
return parseCandidates(text);
|
|
48709
|
+
return sanitizedOrPlaceholder(parseCandidates(text));
|
|
48710
|
+
}
|
|
48711
|
+
function sanitizedOrPlaceholder(candidates) {
|
|
48712
|
+
const clean = sanitizeCandidates(candidates);
|
|
48713
|
+
return clean.length > 0 ? clean : [{ command: 'echo ""', explanation: "QueQue: unexpected response format" }];
|
|
48714
|
+
}
|
|
48715
|
+
var THINK_BLOCK_RE = /<think>[\s\S]*?(?:<\/think>|$)/gi;
|
|
48716
|
+
var THINK_CLOSE = "</think>";
|
|
48717
|
+
function stripThinking(text) {
|
|
48718
|
+
const close = text.toLowerCase().lastIndexOf(THINK_CLOSE);
|
|
48719
|
+
const afterClose = close === -1 ? text : text.slice(close + THINK_CLOSE.length);
|
|
48720
|
+
return afterClose.replace(THINK_BLOCK_RE, " ");
|
|
48721
|
+
}
|
|
48722
|
+
function strictListOrWrapped(text) {
|
|
48723
|
+
const bare = parseStrictCandidateList(text);
|
|
48724
|
+
if (bare) {
|
|
48725
|
+
return bare;
|
|
48726
|
+
}
|
|
48727
|
+
let parsed;
|
|
48728
|
+
try {
|
|
48729
|
+
parsed = JSON.parse(stripCodeFence(text));
|
|
48730
|
+
} catch {
|
|
48731
|
+
return void 0;
|
|
48732
|
+
}
|
|
48733
|
+
if (parsed === null || typeof parsed !== "object" || Array.isArray(parsed)) {
|
|
48734
|
+
return void 0;
|
|
48735
|
+
}
|
|
48736
|
+
const list = candidateListSchema.safeParse(parsed.candidates);
|
|
48737
|
+
return list.success ? list.data : void 0;
|
|
48738
|
+
}
|
|
48739
|
+
function strictCandidateListWithoutProse(text) {
|
|
48740
|
+
return strictListOrWrapped(text) ?? strictListOrWrapped(stripThinking(text));
|
|
48741
|
+
}
|
|
48742
|
+
function withoutCodeFence(text) {
|
|
48743
|
+
return stripCodeFence(text).replace(/^```(?:json)?\s*/, "");
|
|
48744
|
+
}
|
|
48745
|
+
function hasThinkTagOutsideStrings(text) {
|
|
48746
|
+
let inString = false;
|
|
48747
|
+
let escaped = false;
|
|
48748
|
+
for (let i = 0; i < text.length; i++) {
|
|
48749
|
+
const ch = text[i];
|
|
48750
|
+
if (inString) {
|
|
48751
|
+
if (escaped) {
|
|
48752
|
+
escaped = false;
|
|
48753
|
+
} else if (ch === "\\") {
|
|
48754
|
+
escaped = true;
|
|
48755
|
+
} else if (ch === '"') {
|
|
48756
|
+
inString = false;
|
|
48757
|
+
}
|
|
48758
|
+
continue;
|
|
48759
|
+
}
|
|
48760
|
+
if (ch === '"') {
|
|
48761
|
+
inString = true;
|
|
48762
|
+
} else if (ch === "<" && /^<\/?think\b/i.test(text.slice(i, i + 8))) {
|
|
48763
|
+
return true;
|
|
48764
|
+
}
|
|
48765
|
+
}
|
|
48766
|
+
return false;
|
|
48767
|
+
}
|
|
48768
|
+
function answerForScan(text) {
|
|
48769
|
+
const body = withoutCodeFence(text);
|
|
48770
|
+
return /^[[{]/.test(body) && !hasThinkTagOutsideStrings(body) ? body : stripThinking(text);
|
|
48771
|
+
}
|
|
48772
|
+
function finalCandidateListWithoutProse(text, finishedNormally, logFields = {}) {
|
|
48773
|
+
const strict = strictCandidateListWithoutProse(text);
|
|
48774
|
+
if (strict) {
|
|
48775
|
+
return strict;
|
|
48776
|
+
}
|
|
48777
|
+
const answer = answerForScan(text);
|
|
48778
|
+
const arrayStart = answer.search(/\[\s*\{/);
|
|
48779
|
+
const closed = arrayStart === -1 ? [] : completeCandidates(answer.slice(arrayStart));
|
|
48780
|
+
if (closed.length > 0) {
|
|
48781
|
+
return closed;
|
|
48782
|
+
}
|
|
48783
|
+
if (!finishedNormally) {
|
|
48784
|
+
void appendDebugLog("provider", "response truncated", logFields);
|
|
48785
|
+
throw new Error(TRUNCATED_RESPONSE_MESSAGE);
|
|
48786
|
+
}
|
|
48787
|
+
void appendDebugLog("provider", "response unparseable", logFields);
|
|
48788
|
+
throw new Error(UNPARSEABLE_RESPONSE_MESSAGE);
|
|
48670
48789
|
}
|
|
48671
48790
|
function shouldForceSelector() {
|
|
48672
48791
|
const configured = process.env.QQ_FORCE_SELECTOR ?? readEnvValueFromDotEnvLocal("QQ_FORCE_SELECTOR");
|
|
@@ -48714,7 +48833,7 @@ function buildPrompt(envelope) {
|
|
|
48714
48833
|
async function fetchCandidates(envelope, rbuffer = "", timeoutMs = 25e3, options = {}) {
|
|
48715
48834
|
const apiKey = usableSecret(process.env.ANTHROPIC_API_KEY) ?? usableSecret(readEnvValueFromDotEnvLocal("ANTHROPIC_API_KEY"));
|
|
48716
48835
|
if (!apiKey) {
|
|
48717
|
-
throw new Error("ANTHROPIC_API_KEY is required in the environment or
|
|
48836
|
+
throw new Error("ANTHROPIC_API_KEY is required in the environment or ~/.env.local");
|
|
48718
48837
|
}
|
|
48719
48838
|
const client = await getAnthropicClient(apiKey);
|
|
48720
48839
|
const prompt = buildPrompt(envelope);
|
|
@@ -48742,9 +48861,13 @@ async function fetchCandidates(envelope, rbuffer = "", timeoutMs = 25e3, options
|
|
|
48742
48861
|
);
|
|
48743
48862
|
if (onCandidate) {
|
|
48744
48863
|
const scan = createCandidateScanner((candidate) => {
|
|
48745
|
-
|
|
48864
|
+
const clean = sanitizeCandidate(candidate);
|
|
48865
|
+
if (!clean) {
|
|
48866
|
+
return;
|
|
48867
|
+
}
|
|
48868
|
+
streamed.push(clean);
|
|
48746
48869
|
if (!signal?.aborted) {
|
|
48747
|
-
onCandidate(
|
|
48870
|
+
onCandidate(clean);
|
|
48748
48871
|
}
|
|
48749
48872
|
});
|
|
48750
48873
|
stream.on("text", (textDelta) => {
|
|
@@ -48940,7 +49063,7 @@ function runClaudeTurn(options) {
|
|
|
48940
49063
|
})
|
|
48941
49064
|
);
|
|
48942
49065
|
}
|
|
48943
|
-
return new Promise((
|
|
49066
|
+
return new Promise((resolve5, reject) => {
|
|
48944
49067
|
let settled = false;
|
|
48945
49068
|
let sawInit = false;
|
|
48946
49069
|
let sawDelta = false;
|
|
@@ -49091,7 +49214,7 @@ function runClaudeTurn(options) {
|
|
|
49091
49214
|
return;
|
|
49092
49215
|
}
|
|
49093
49216
|
onStage?.("result");
|
|
49094
|
-
finish(() =>
|
|
49217
|
+
finish(() => resolve5(parsed.data.result ?? ""));
|
|
49095
49218
|
};
|
|
49096
49219
|
if (!prewarmed && child.pid !== void 0) {
|
|
49097
49220
|
onStage?.("spawned", { pid: child.pid });
|
|
@@ -49320,12 +49443,16 @@ async function fetchClaudeCliCandidates(envelope, remainingBudgetMs, options = {
|
|
|
49320
49443
|
};
|
|
49321
49444
|
const prompt = buildPrompt(envelope);
|
|
49322
49445
|
const createTextDeltaHandler = () => onCandidate ? createCandidateScanner((candidate) => {
|
|
49323
|
-
|
|
49446
|
+
const clean = sanitizeCandidate(candidate);
|
|
49447
|
+
if (!clean) {
|
|
49448
|
+
return;
|
|
49449
|
+
}
|
|
49450
|
+
streamed.push(clean);
|
|
49324
49451
|
if (streamed.length === 1) {
|
|
49325
49452
|
void appendDebugLog("provider", "cli first candidate", { ms: Date.now() - startedAt });
|
|
49326
49453
|
}
|
|
49327
49454
|
if (!signal?.aborted) {
|
|
49328
|
-
onCandidate(
|
|
49455
|
+
onCandidate(clean);
|
|
49329
49456
|
}
|
|
49330
49457
|
}) : void 0;
|
|
49331
49458
|
const runTurn = (child, budgetMs, initDeadlineMs) => runClaudeTurn({
|
|
@@ -49413,9 +49540,12 @@ function logTurnStage(stage, detail, ms, warm) {
|
|
|
49413
49540
|
// src/providers/claude-default.ts
|
|
49414
49541
|
var TOTAL_BUDGET_MS = 25e3;
|
|
49415
49542
|
var AUTH_FAILURE_RE = /not logged in|login expired|please run \/login|failed to authenticate|oauth (token|session)/i;
|
|
49416
|
-
var D13_MESSAGE = "QueQue: Claude is not authenticated. Run `claude /login`, or set ANTHROPIC_API_KEY in the environment or
|
|
49417
|
-
var ENOENT_MESSAGE = "QueQue:
|
|
49418
|
-
var
|
|
49543
|
+
var D13_MESSAGE = "QueQue: Claude is not authenticated. Run `claude /login`, or set ANTHROPIC_API_KEY in the environment or ~/.env.local. To use OpenAI or Ollama instead, run `qq init provider`.";
|
|
49544
|
+
var ENOENT_MESSAGE = "QueQue: No AI provider is ready. Install Claude Code and run `claude /login`, or set ANTHROPIC_API_KEY in the environment or ~/.env.local. To use OpenAI or Ollama instead, run `qq init provider`.";
|
|
49545
|
+
var CLI_FAILED_MESSAGE = 'QueQue: Claude Code could not answer (claude -p failed). Try ?? again; run `claude -p "hi"` to see the error.';
|
|
49546
|
+
var SDK_KEY_REJECTED_MESSAGE = "QueQue: Anthropic rejected ANTHROPIC_API_KEY (HTTP 401). Check the key in your environment or ~/.env.local, remove it to use your Claude Code login, or run `qq init provider` to switch providers.";
|
|
49547
|
+
var SDK_KEY_REFUSED_MESSAGE = "QueQue: Anthropic refused the request for ANTHROPIC_API_KEY (HTTP 403). Check the key's permissions, remove it to use your Claude Code login, or run `qq init provider` to switch providers.";
|
|
49548
|
+
var TIMEOUT_MESSAGE = "QueQue: Claude timed out. Run `claude /login`, or set ANTHROPIC_API_KEY in the environment or ~/.env.local.";
|
|
49419
49549
|
function remainingMs(deadline) {
|
|
49420
49550
|
return Math.max(0, deadline - Date.now());
|
|
49421
49551
|
}
|
|
@@ -49462,7 +49592,20 @@ function hardError(error43) {
|
|
|
49462
49592
|
if (isAuthFailure(error43)) {
|
|
49463
49593
|
return new Error(D13_MESSAGE);
|
|
49464
49594
|
}
|
|
49465
|
-
return new Error(
|
|
49595
|
+
return new Error(CLI_FAILED_MESSAGE);
|
|
49596
|
+
}
|
|
49597
|
+
function sdkError(error43) {
|
|
49598
|
+
if (isAbortError(error43)) {
|
|
49599
|
+
return error43;
|
|
49600
|
+
}
|
|
49601
|
+
const status = errorField(error43, "status");
|
|
49602
|
+
if (status === 401) {
|
|
49603
|
+
return new Error(SDK_KEY_REJECTED_MESSAGE);
|
|
49604
|
+
}
|
|
49605
|
+
if (status === 403) {
|
|
49606
|
+
return new Error(SDK_KEY_REFUSED_MESSAGE);
|
|
49607
|
+
}
|
|
49608
|
+
return error43;
|
|
49466
49609
|
}
|
|
49467
49610
|
var claudeDefaultAdapter = {
|
|
49468
49611
|
async fetchCandidates(envelope, options) {
|
|
@@ -49472,7 +49615,11 @@ var claudeDefaultAdapter = {
|
|
|
49472
49615
|
void appendDebugLog("provider", "sdk path", {
|
|
49473
49616
|
path: "sdk"
|
|
49474
49617
|
});
|
|
49475
|
-
|
|
49618
|
+
try {
|
|
49619
|
+
return await fetchCandidates(envelope, "", remainingMs(deadline), options);
|
|
49620
|
+
} catch (error43) {
|
|
49621
|
+
throw sdkError(error43);
|
|
49622
|
+
}
|
|
49476
49623
|
}
|
|
49477
49624
|
try {
|
|
49478
49625
|
return await fetchClaudeCliCandidates(envelope, remainingMs(deadline), options);
|
|
@@ -49491,28 +49638,693 @@ var claudeDefaultAdapter = {
|
|
|
49491
49638
|
}
|
|
49492
49639
|
};
|
|
49493
49640
|
|
|
49494
|
-
// src/
|
|
49641
|
+
// src/providers/provider-pin.ts
|
|
49642
|
+
import { randomBytes } from "crypto";
|
|
49643
|
+
import { chmodSync, mkdirSync, readFileSync as readFileSync3, renameSync, unlinkSync, writeFileSync } from "fs";
|
|
49644
|
+
import { homedir as homedir3 } from "os";
|
|
49645
|
+
import { dirname as dirname2, isAbsolute as isAbsolute2, join as join3 } from "path";
|
|
49646
|
+
|
|
49647
|
+
// src/registry/provider-backends.ts
|
|
49495
49648
|
var registry2 = /* @__PURE__ */ new Map();
|
|
49496
|
-
function
|
|
49497
|
-
if (registry2.has(
|
|
49498
|
-
throw new Error(`
|
|
49649
|
+
function registerProviderBackend(registration) {
|
|
49650
|
+
if (registry2.has(registration.id)) {
|
|
49651
|
+
throw new Error(`Provider backend already registered: "${registration.id}"`);
|
|
49499
49652
|
}
|
|
49500
|
-
registry2.set(
|
|
49653
|
+
registry2.set(registration.id, registration);
|
|
49501
49654
|
}
|
|
49502
|
-
function
|
|
49503
|
-
return
|
|
49655
|
+
function getProviderAdapter(id) {
|
|
49656
|
+
return registry2.get(id)?.adapter;
|
|
49504
49657
|
}
|
|
49505
49658
|
|
|
49506
|
-
// src/
|
|
49659
|
+
// src/providers/resolver.ts
|
|
49660
|
+
var MISSING_ADAPTER_MESSAGE = "QueQue: Claude provider is not registered \u2014 was bootstrapBuiltins() called?";
|
|
49661
|
+
function resolveClaudeDefaultAdapter() {
|
|
49662
|
+
const adapter = getProviderAdapter("claude-cli");
|
|
49663
|
+
if (!adapter) {
|
|
49664
|
+
throw new Error(MISSING_ADAPTER_MESSAGE);
|
|
49665
|
+
}
|
|
49666
|
+
return adapter;
|
|
49667
|
+
}
|
|
49668
|
+
|
|
49669
|
+
// src/providers/provider-pin.ts
|
|
49670
|
+
var PROVIDER_PIN_VERSION = 1;
|
|
49671
|
+
var OLLAMA_DEFAULT_BASE_URL = "http://localhost:11434";
|
|
49672
|
+
var modelName = external_exports.string().trim().min(1).max(200).regex(/^[^\p{Cc}]+$/u, { message: "model must not contain control characters" });
|
|
49673
|
+
var httpUrl2 = external_exports.string().min(1).refine((value) => !UNSAFE_LINE_CHARS.test(value), {
|
|
49674
|
+
message: "baseUrl must not contain control or format characters"
|
|
49675
|
+
}).refine(
|
|
49676
|
+
(value) => {
|
|
49677
|
+
try {
|
|
49678
|
+
const { protocol, username, password } = new URL(value);
|
|
49679
|
+
return (protocol === "http:" || protocol === "https:") && !username && !password;
|
|
49680
|
+
} catch {
|
|
49681
|
+
return false;
|
|
49682
|
+
}
|
|
49683
|
+
},
|
|
49684
|
+
{ message: "baseUrl must be an http or https URL without a username or password" }
|
|
49685
|
+
);
|
|
49686
|
+
var version2 = external_exports.literal(PROVIDER_PIN_VERSION);
|
|
49687
|
+
var providerPinSchema = external_exports.discriminatedUnion("provider", [
|
|
49688
|
+
external_exports.strictObject({ version: version2, provider: external_exports.literal("claude") }),
|
|
49689
|
+
external_exports.strictObject({ version: version2, provider: external_exports.literal("openai"), model: modelName.optional() }),
|
|
49690
|
+
external_exports.strictObject({
|
|
49691
|
+
version: version2,
|
|
49692
|
+
provider: external_exports.literal("ollama"),
|
|
49693
|
+
model: modelName,
|
|
49694
|
+
baseUrl: httpUrl2.optional()
|
|
49695
|
+
})
|
|
49696
|
+
]);
|
|
49697
|
+
var PIN_BACKEND_IDS = {
|
|
49698
|
+
claude: "claude-cli",
|
|
49699
|
+
openai: "openai",
|
|
49700
|
+
ollama: "ollama"
|
|
49701
|
+
};
|
|
49702
|
+
function providerPinPath() {
|
|
49703
|
+
const override = process.env.QQ_PROVIDER_FILE?.trim();
|
|
49704
|
+
return override ? override : join3(homedir3(), ".config", "qq", "provider.json");
|
|
49705
|
+
}
|
|
49706
|
+
var RELATIVE_PIN_PATH_MESSAGE = "QQ_PROVIDER_FILE must be an absolute path";
|
|
49707
|
+
var MAX_ISSUE_REASON = 120;
|
|
49708
|
+
function describeIssues(error43) {
|
|
49709
|
+
const parts = error43.issues.map((issue2) => {
|
|
49710
|
+
if (issue2.code === "unrecognized_keys") {
|
|
49711
|
+
return `unknown key ${issue2.keys.join(", ")}`;
|
|
49712
|
+
}
|
|
49713
|
+
return issue2.path.length > 0 ? issue2.path.join(".") : issue2.code;
|
|
49714
|
+
});
|
|
49715
|
+
const reason = [...new Set(parts)].join(", ").replace(new RegExp("\\p{Cc}", "gu"), "?");
|
|
49716
|
+
return reason.length > MAX_ISSUE_REASON ? `${reason.slice(0, MAX_ISSUE_REASON - 1)}\u2026` : reason;
|
|
49717
|
+
}
|
|
49718
|
+
function loadProviderPin() {
|
|
49719
|
+
const path5 = providerPinPath();
|
|
49720
|
+
if (!isAbsolute2(path5)) {
|
|
49721
|
+
return { kind: "invalid", path: path5, message: RELATIVE_PIN_PATH_MESSAGE };
|
|
49722
|
+
}
|
|
49723
|
+
let raw;
|
|
49724
|
+
try {
|
|
49725
|
+
raw = readFileSync3(path5, "utf8");
|
|
49726
|
+
} catch (error43) {
|
|
49727
|
+
const code = error43.code;
|
|
49728
|
+
if (code === "ENOENT") {
|
|
49729
|
+
return { kind: "absent" };
|
|
49730
|
+
}
|
|
49731
|
+
return { kind: "invalid", path: path5, message: code ?? "unreadable" };
|
|
49732
|
+
}
|
|
49733
|
+
let parsed;
|
|
49734
|
+
try {
|
|
49735
|
+
parsed = JSON.parse(raw);
|
|
49736
|
+
} catch {
|
|
49737
|
+
return { kind: "invalid", path: path5, message: "not valid JSON" };
|
|
49738
|
+
}
|
|
49739
|
+
const result = providerPinSchema.safeParse(parsed);
|
|
49740
|
+
if (!result.success) {
|
|
49741
|
+
return { kind: "invalid", path: path5, message: describeIssues(result.error) };
|
|
49742
|
+
}
|
|
49743
|
+
return { kind: "pinned", pin: result.data };
|
|
49744
|
+
}
|
|
49745
|
+
function writeProviderPin(pin) {
|
|
49746
|
+
const parsed = providerPinSchema.parse(pin);
|
|
49747
|
+
const target = providerPinPath();
|
|
49748
|
+
if (!isAbsolute2(target)) {
|
|
49749
|
+
throw new Error(RELATIVE_PIN_PATH_MESSAGE);
|
|
49750
|
+
}
|
|
49751
|
+
mkdirSync(dirname2(target), { recursive: true, mode: 448 });
|
|
49752
|
+
const temp = `${target}.${process.pid}.${randomBytes(4).toString("hex")}.tmp`;
|
|
49753
|
+
try {
|
|
49754
|
+
writeFileSync(temp, `${JSON.stringify(parsed, null, 2)}
|
|
49755
|
+
`, { mode: 384, flag: "wx" });
|
|
49756
|
+
chmodSync(temp, 384);
|
|
49757
|
+
renameSync(temp, target);
|
|
49758
|
+
} catch (error43) {
|
|
49759
|
+
try {
|
|
49760
|
+
unlinkSync(temp);
|
|
49761
|
+
} catch {
|
|
49762
|
+
}
|
|
49763
|
+
throw error43;
|
|
49764
|
+
}
|
|
49765
|
+
return target;
|
|
49766
|
+
}
|
|
49767
|
+
function resolveProviderAdapter() {
|
|
49768
|
+
const state = loadProviderPin();
|
|
49769
|
+
if (state.kind === "absent") {
|
|
49770
|
+
void appendDebugLog("provider", "provider selected", { provider: "claude", source: "default" });
|
|
49771
|
+
return resolveClaudeDefaultAdapter();
|
|
49772
|
+
}
|
|
49773
|
+
if (state.kind === "invalid") {
|
|
49774
|
+
void appendDebugLog("provider", "provider selected", { source: "invalid" });
|
|
49775
|
+
throw new Error(
|
|
49776
|
+
`QueQue: ${state.path} is not a valid provider pin (${state.message}). Fix the file or run \`qq init provider\`.`
|
|
49777
|
+
);
|
|
49778
|
+
}
|
|
49779
|
+
const { provider } = state.pin;
|
|
49780
|
+
void appendDebugLog("provider", "provider selected", { provider, source: "pin" });
|
|
49781
|
+
if (provider === "claude") {
|
|
49782
|
+
return resolveClaudeDefaultAdapter();
|
|
49783
|
+
}
|
|
49784
|
+
const adapter = getProviderAdapter(PIN_BACKEND_IDS[provider]);
|
|
49785
|
+
if (!adapter) {
|
|
49786
|
+
throw new Error(
|
|
49787
|
+
`QueQue: provider '${provider}' is not registered \u2014 was bootstrapBuiltins() called?`
|
|
49788
|
+
);
|
|
49789
|
+
}
|
|
49790
|
+
return adapter;
|
|
49791
|
+
}
|
|
49792
|
+
|
|
49793
|
+
// src/providers/structured-output.ts
|
|
49794
|
+
var MAX_OUTPUT_TOKENS = SDK_MAX_TOKENS;
|
|
49795
|
+
var CANDIDATE_LIST_JSON_SCHEMA = {
|
|
49796
|
+
type: "array",
|
|
49797
|
+
minItems: 1,
|
|
49798
|
+
maxItems: 5,
|
|
49799
|
+
items: {
|
|
49800
|
+
type: "object",
|
|
49801
|
+
properties: {
|
|
49802
|
+
command: { type: "string", minLength: 1 },
|
|
49803
|
+
explanation: { type: "string" }
|
|
49804
|
+
},
|
|
49805
|
+
required: ["command", "explanation"],
|
|
49806
|
+
additionalProperties: false
|
|
49807
|
+
}
|
|
49808
|
+
};
|
|
49809
|
+
var WRAPPED_CANDIDATE_LIST_JSON_SCHEMA = {
|
|
49810
|
+
type: "object",
|
|
49811
|
+
properties: {
|
|
49812
|
+
candidates: CANDIDATE_LIST_JSON_SCHEMA
|
|
49813
|
+
},
|
|
49814
|
+
required: ["candidates"],
|
|
49815
|
+
additionalProperties: false
|
|
49816
|
+
};
|
|
49817
|
+
function closedCandidates(content, logFields) {
|
|
49818
|
+
try {
|
|
49819
|
+
return finalCandidateListWithoutProse(content, false, logFields);
|
|
49820
|
+
} catch (error43) {
|
|
49821
|
+
if (error43 instanceof Error && error43.message === TRUNCATED_RESPONSE_MESSAGE) {
|
|
49822
|
+
return [];
|
|
49823
|
+
}
|
|
49824
|
+
throw error43;
|
|
49825
|
+
}
|
|
49826
|
+
}
|
|
49827
|
+
async function candidatesWithCutOffRetry(first, retry, logFields = {}, budget) {
|
|
49828
|
+
if (first.finishedNormally) {
|
|
49829
|
+
return finalCandidateListWithoutProse(first.content, true, logFields);
|
|
49830
|
+
}
|
|
49831
|
+
const complete = strictCandidateListWithoutProse(first.content);
|
|
49832
|
+
if (complete) {
|
|
49833
|
+
return complete;
|
|
49834
|
+
}
|
|
49835
|
+
const closed = closedCandidates(first.content, logFields);
|
|
49836
|
+
void appendDebugLog("provider", "response cut off, retrying once", logFields);
|
|
49837
|
+
try {
|
|
49838
|
+
const second = await retry();
|
|
49839
|
+
return finalCandidateListWithoutProse(second.content, second.finishedNormally, logFields);
|
|
49840
|
+
} catch (error43) {
|
|
49841
|
+
if (isAbortError(error43)) {
|
|
49842
|
+
throw error43;
|
|
49843
|
+
}
|
|
49844
|
+
if (closed.length === 0) {
|
|
49845
|
+
if (budget?.aborted) {
|
|
49846
|
+
void appendDebugLog("provider", "response truncated", logFields);
|
|
49847
|
+
throw new Error(TRUNCATED_RESPONSE_MESSAGE);
|
|
49848
|
+
}
|
|
49849
|
+
throw error43;
|
|
49850
|
+
}
|
|
49851
|
+
return closed;
|
|
49852
|
+
}
|
|
49853
|
+
}
|
|
49854
|
+
|
|
49855
|
+
// src/providers/ollama.ts
|
|
49856
|
+
var OLLAMA_TIMEOUT_MS = 25e3;
|
|
49857
|
+
var OLLAMA_NUM_PREDICT = 2048;
|
|
49858
|
+
var OLLAMA_NUM_CTX = 8192;
|
|
49859
|
+
var MAX_ERROR_DETAIL = 160;
|
|
49860
|
+
var SWITCH_HINT = "Run `qq init provider` to switch providers.";
|
|
49861
|
+
var UNREACHABLE_CODES = /* @__PURE__ */ new Set(["ECONNREFUSED", "ENOTFOUND", "EHOSTUNREACH"]);
|
|
49862
|
+
function errorCode(error43) {
|
|
49863
|
+
const cause = error43?.cause;
|
|
49864
|
+
return typeof cause?.code === "string" ? cause.code : void 0;
|
|
49865
|
+
}
|
|
49866
|
+
function errorName(error43) {
|
|
49867
|
+
const name = error43?.name;
|
|
49868
|
+
return typeof name === "string" ? name : void 0;
|
|
49869
|
+
}
|
|
49870
|
+
function oneLine(text) {
|
|
49871
|
+
const flat = replaceUnsafeLineChars(text).replace(/\s+/g, " ").trim();
|
|
49872
|
+
return flat.length > MAX_ERROR_DETAIL ? `${flat.slice(0, MAX_ERROR_DETAIL)}\u2026` : flat;
|
|
49873
|
+
}
|
|
49874
|
+
function unexpectedResponse() {
|
|
49875
|
+
return new Error(`QueQue: Ollama returned an unexpected response. ${SWITCH_HINT}`);
|
|
49876
|
+
}
|
|
49877
|
+
function mapRequestFailure(error43, origin, timeoutMs, signal) {
|
|
49878
|
+
if (signal?.aborted) {
|
|
49879
|
+
return abortError();
|
|
49880
|
+
}
|
|
49881
|
+
const name = errorName(error43);
|
|
49882
|
+
if (name === "TimeoutError" || name === "AbortError") {
|
|
49883
|
+
const seconds = Math.ceil(timeoutMs / 1e3);
|
|
49884
|
+
return new Error(
|
|
49885
|
+
`QueQue: Ollama did not answer within ${seconds}s (the model may still be loading). Try ?? again.`
|
|
49886
|
+
);
|
|
49887
|
+
}
|
|
49888
|
+
const code = errorCode(error43);
|
|
49889
|
+
if (code && UNREACHABLE_CODES.has(code)) {
|
|
49890
|
+
return new Error(
|
|
49891
|
+
`QueQue: Ollama is not reachable at ${origin}. Start it with \`ollama serve\`, or run \`qq init provider\` to switch providers.`
|
|
49892
|
+
);
|
|
49893
|
+
}
|
|
49894
|
+
return new Error(
|
|
49895
|
+
`QueQue: Ollama request to ${origin} failed (${code ?? name ?? "error"}). ${SWITCH_HINT}`
|
|
49896
|
+
);
|
|
49897
|
+
}
|
|
49898
|
+
function ollamaApiUrl(baseUrl, path5) {
|
|
49899
|
+
const url2 = new URL(baseUrl);
|
|
49900
|
+
url2.pathname = `${url2.pathname.replace(/\/+$/, "")}/${path5}`;
|
|
49901
|
+
url2.search = "";
|
|
49902
|
+
url2.hash = "";
|
|
49903
|
+
return url2;
|
|
49904
|
+
}
|
|
49905
|
+
async function readErrorField(response) {
|
|
49906
|
+
try {
|
|
49907
|
+
const body = await response.json();
|
|
49908
|
+
if (typeof body?.error === "string" && body.error.trim() !== "") {
|
|
49909
|
+
return body.error;
|
|
49910
|
+
}
|
|
49911
|
+
} catch {
|
|
49912
|
+
}
|
|
49913
|
+
return void 0;
|
|
49914
|
+
}
|
|
49915
|
+
async function readErrorDetail(response) {
|
|
49916
|
+
const error43 = await readErrorField(response);
|
|
49917
|
+
if (error43 !== void 0) {
|
|
49918
|
+
return oneLine(error43);
|
|
49919
|
+
}
|
|
49920
|
+
return oneLine(response.statusText) || "no detail";
|
|
49921
|
+
}
|
|
49922
|
+
async function fetchOllamaCandidates(envelope, settings, timeoutMs = OLLAMA_TIMEOUT_MS, options = {}) {
|
|
49923
|
+
const { signal } = options;
|
|
49924
|
+
if (signal?.aborted) {
|
|
49925
|
+
throw abortError();
|
|
49926
|
+
}
|
|
49927
|
+
const url2 = ollamaApiUrl(settings.baseUrl, "api/chat");
|
|
49928
|
+
const { origin } = url2;
|
|
49929
|
+
const timeout = AbortSignal.timeout(timeoutMs);
|
|
49930
|
+
const requestSignal = signal ? AbortSignal.any([signal, timeout]) : timeout;
|
|
49931
|
+
const requestBody = JSON.stringify({
|
|
49932
|
+
model: settings.model,
|
|
49933
|
+
stream: false,
|
|
49934
|
+
think: false,
|
|
49935
|
+
format: CANDIDATE_LIST_JSON_SCHEMA,
|
|
49936
|
+
options: { num_predict: OLLAMA_NUM_PREDICT, num_ctx: OLLAMA_NUM_CTX },
|
|
49937
|
+
messages: [
|
|
49938
|
+
{ role: "system", content: buildSystemPrompt(envelope) },
|
|
49939
|
+
{ role: "user", content: buildPrompt(envelope) }
|
|
49940
|
+
]
|
|
49941
|
+
});
|
|
49942
|
+
const postChat = async () => {
|
|
49943
|
+
const started = Date.now();
|
|
49944
|
+
const logRequest = (status) => {
|
|
49945
|
+
void appendDebugLog("provider", "ollama request", {
|
|
49946
|
+
model: settings.model,
|
|
49947
|
+
status,
|
|
49948
|
+
durationMs: Date.now() - started
|
|
49949
|
+
});
|
|
49950
|
+
};
|
|
49951
|
+
let response;
|
|
49952
|
+
try {
|
|
49953
|
+
response = await fetch(url2, {
|
|
49954
|
+
method: "POST",
|
|
49955
|
+
headers: { "content-type": "application/json" },
|
|
49956
|
+
body: requestBody,
|
|
49957
|
+
signal: requestSignal
|
|
49958
|
+
});
|
|
49959
|
+
} catch (error43) {
|
|
49960
|
+
logRequest(null);
|
|
49961
|
+
throw mapRequestFailure(error43, origin, timeoutMs, signal);
|
|
49962
|
+
}
|
|
49963
|
+
logRequest(response.status);
|
|
49964
|
+
if (response.status === 404) {
|
|
49965
|
+
const error43 = await readErrorField(response);
|
|
49966
|
+
if (error43 !== void 0 && /\bmodel\b/i.test(error43)) {
|
|
49967
|
+
throw new Error(
|
|
49968
|
+
`QueQue: Ollama model '${settings.model}' is not installed. Run \`ollama pull ${settings.model}\`, or run \`qq init provider\` to pick another model.`
|
|
49969
|
+
);
|
|
49970
|
+
}
|
|
49971
|
+
throw new Error(
|
|
49972
|
+
`QueQue: Ollama returned HTTP 404 from ${origin}. Check "baseUrl" in provider.json, or run \`qq init provider\`.`
|
|
49973
|
+
);
|
|
49974
|
+
}
|
|
49975
|
+
if (!response.ok) {
|
|
49976
|
+
const detail = await readErrorDetail(response);
|
|
49977
|
+
throw new Error(`QueQue: Ollama returned HTTP ${response.status}: ${detail}. ${SWITCH_HINT}`);
|
|
49978
|
+
}
|
|
49979
|
+
let raw;
|
|
49980
|
+
try {
|
|
49981
|
+
raw = await response.text();
|
|
49982
|
+
} catch (error43) {
|
|
49983
|
+
throw mapRequestFailure(error43, origin, timeoutMs, signal);
|
|
49984
|
+
}
|
|
49985
|
+
let body;
|
|
49986
|
+
try {
|
|
49987
|
+
body = JSON.parse(raw);
|
|
49988
|
+
} catch {
|
|
49989
|
+
throw unexpectedResponse();
|
|
49990
|
+
}
|
|
49991
|
+
const content = body?.message?.content;
|
|
49992
|
+
if (typeof content !== "string") {
|
|
49993
|
+
throw unexpectedResponse();
|
|
49994
|
+
}
|
|
49995
|
+
return { content, finishedNormally: body.done_reason === "stop" };
|
|
49996
|
+
};
|
|
49997
|
+
const first = await postChat();
|
|
49998
|
+
try {
|
|
49999
|
+
return ensureSelectableCandidates(
|
|
50000
|
+
stripTerminalControls(
|
|
50001
|
+
await candidatesWithCutOffRetry(first, postChat, { model: settings.model }, timeout)
|
|
50002
|
+
)
|
|
50003
|
+
);
|
|
50004
|
+
} catch (error43) {
|
|
50005
|
+
if (error43 instanceof Error && error43.message === TRUNCATED_RESPONSE_MESSAGE) {
|
|
50006
|
+
throw new Error(
|
|
50007
|
+
"QueQue: Ollama response was cut off before a full command. Try ?? again, or run `qq init provider` to pick another model."
|
|
50008
|
+
);
|
|
50009
|
+
}
|
|
50010
|
+
if (error43 instanceof Error && error43.message === UNPARSEABLE_RESPONSE_MESSAGE) {
|
|
50011
|
+
throw unexpectedResponse();
|
|
50012
|
+
}
|
|
50013
|
+
throw error43;
|
|
50014
|
+
}
|
|
50015
|
+
}
|
|
50016
|
+
var ollamaAdapter = {
|
|
50017
|
+
fetchCandidates(envelope, options) {
|
|
50018
|
+
const state = loadProviderPin();
|
|
50019
|
+
if (state.kind !== "pinned" || state.pin.provider !== "ollama") {
|
|
50020
|
+
return Promise.reject(
|
|
50021
|
+
new Error("QueQue: Ollama is not the pinned provider. Run `qq init provider`.")
|
|
50022
|
+
);
|
|
50023
|
+
}
|
|
50024
|
+
return fetchOllamaCandidates(
|
|
50025
|
+
envelope,
|
|
50026
|
+
{ baseUrl: state.pin.baseUrl ?? OLLAMA_DEFAULT_BASE_URL, model: state.pin.model },
|
|
50027
|
+
OLLAMA_TIMEOUT_MS,
|
|
50028
|
+
options
|
|
50029
|
+
);
|
|
50030
|
+
}
|
|
50031
|
+
};
|
|
50032
|
+
var OLLAMA_LIST_TIMEOUT_MS = 2e3;
|
|
50033
|
+
var CONTROL_BYTES = /[\p{Cc}]/u;
|
|
50034
|
+
function listableModelName(value) {
|
|
50035
|
+
return typeof value === "string" && value.trim().length > 0 && value.length <= 200 && !CONTROL_BYTES.test(value);
|
|
50036
|
+
}
|
|
50037
|
+
async function listOllamaModels(baseUrl = OLLAMA_DEFAULT_BASE_URL, timeoutMs = OLLAMA_LIST_TIMEOUT_MS) {
|
|
50038
|
+
const signal = AbortSignal.timeout(timeoutMs);
|
|
50039
|
+
let response;
|
|
50040
|
+
try {
|
|
50041
|
+
response = await fetch(ollamaApiUrl(baseUrl, "api/tags"), { signal });
|
|
50042
|
+
} catch {
|
|
50043
|
+
return { ok: false, reason: "unreachable" };
|
|
50044
|
+
}
|
|
50045
|
+
if (!response.ok) {
|
|
50046
|
+
await response.body?.cancel().catch(() => void 0);
|
|
50047
|
+
return { ok: false, reason: "http", status: response.status };
|
|
50048
|
+
}
|
|
50049
|
+
let body;
|
|
50050
|
+
try {
|
|
50051
|
+
body = await response.json();
|
|
50052
|
+
} catch {
|
|
50053
|
+
return signal.aborted ? { ok: false, reason: "unreachable" } : { ok: false, reason: "http", status: response.status };
|
|
50054
|
+
}
|
|
50055
|
+
const models = body?.models;
|
|
50056
|
+
if (!Array.isArray(models)) {
|
|
50057
|
+
return { ok: false, reason: "http", status: response.status };
|
|
50058
|
+
}
|
|
50059
|
+
const names = models.map((entry) => entry?.name).filter(listableModelName);
|
|
50060
|
+
return { ok: true, models: names };
|
|
50061
|
+
}
|
|
50062
|
+
|
|
50063
|
+
// src/providers/openai.ts
|
|
50064
|
+
var OPENAI_CHAT_COMPLETIONS_URL = "https://api.openai.com/v1/chat/completions";
|
|
50065
|
+
var OPENAI_DEFAULT_MODEL = "gpt-5.5";
|
|
50066
|
+
var OPENAI_TIMEOUT_MS = 25e3;
|
|
50067
|
+
var OPENAI_REASONING_EFFORT = "low";
|
|
50068
|
+
var OPENAI_RETRY_REASONING_EFFORTS = ["none", "minimal", "low"];
|
|
50069
|
+
var OPENAI_RESPONSE_FORMAT_NAME = "command_candidates";
|
|
50070
|
+
var modelsRejectingDefaultEffort = /* @__PURE__ */ new Set();
|
|
50071
|
+
var modelsRejectingSchema = /* @__PURE__ */ new Set();
|
|
50072
|
+
var rejectedEffortsByModel = /* @__PURE__ */ new Map();
|
|
50073
|
+
function rememberRejectedEffort(model, effort) {
|
|
50074
|
+
const rejected = rejectedEffortsByModel.get(model) ?? /* @__PURE__ */ new Set();
|
|
50075
|
+
rejected.add(effort);
|
|
50076
|
+
rejectedEffortsByModel.set(model, rejected);
|
|
50077
|
+
}
|
|
50078
|
+
function lookupOpenAiKey() {
|
|
50079
|
+
return usableSecret(process.env.OPENAI_API_KEY) ?? usableSecret(readEnvValueFromDotEnvLocal("OPENAI_API_KEY"));
|
|
50080
|
+
}
|
|
50081
|
+
var SAFE_ERROR_CODE = /^[a-z0-9_]{1,64}$/;
|
|
50082
|
+
var SWITCH_HINT2 = "run `qq init provider` to switch providers";
|
|
50083
|
+
var HEADER_SAFE_KEY = /^[\x21-\x7e]+$/;
|
|
50084
|
+
function errorName2(error43) {
|
|
50085
|
+
const name = error43?.name;
|
|
50086
|
+
return typeof name === "string" ? name : void 0;
|
|
50087
|
+
}
|
|
50088
|
+
function unexpectedResponse2() {
|
|
50089
|
+
return new Error("QueQue: OpenAI returned an unexpected response.");
|
|
50090
|
+
}
|
|
50091
|
+
function declinedQuery() {
|
|
50092
|
+
return new Error("QueQue: OpenAI declined this query. Rephrase it and press ?? again.");
|
|
50093
|
+
}
|
|
50094
|
+
function oneLine2(text) {
|
|
50095
|
+
return text.replace(/\s+/g, " ").trim();
|
|
50096
|
+
}
|
|
50097
|
+
async function readSafeErrorFields(response) {
|
|
50098
|
+
try {
|
|
50099
|
+
const body = await response.json();
|
|
50100
|
+
const code = body?.error?.code;
|
|
50101
|
+
const param = body?.error?.param;
|
|
50102
|
+
return {
|
|
50103
|
+
code: typeof code === "string" && SAFE_ERROR_CODE.test(code) ? code : void 0,
|
|
50104
|
+
rejectsReasoningEffort: param === "reasoning_effort",
|
|
50105
|
+
rejectsResponseFormat: typeof param === "string" && (param === "response_format" || param.startsWith("response_format."))
|
|
50106
|
+
};
|
|
50107
|
+
} catch {
|
|
50108
|
+
return { code: void 0, rejectsReasoningEffort: false, rejectsResponseFormat: false };
|
|
50109
|
+
}
|
|
50110
|
+
}
|
|
50111
|
+
function statusFailure(status, model, code) {
|
|
50112
|
+
switch (status) {
|
|
50113
|
+
case 401:
|
|
50114
|
+
return new Error(
|
|
50115
|
+
`QueQue: OpenAI rejected OPENAI_API_KEY (HTTP 401). Check the key, or ${SWITCH_HINT2}.`
|
|
50116
|
+
);
|
|
50117
|
+
case 403:
|
|
50118
|
+
return new Error(
|
|
50119
|
+
"QueQue: OpenAI refused the request (HTTP 403). Check the key's project access, or run `qq init provider`."
|
|
50120
|
+
);
|
|
50121
|
+
case 404:
|
|
50122
|
+
return new Error(
|
|
50123
|
+
`QueQue: OpenAI model '${oneLine2(model)}' is not available to this key (HTTP 404). Set "model" in ~/.config/qq/provider.json, or run \`qq init provider\`.`
|
|
50124
|
+
);
|
|
50125
|
+
case 429:
|
|
50126
|
+
return new Error(
|
|
50127
|
+
`QueQue: OpenAI rate limit or quota reached (HTTP 429). Try again shortly, or ${SWITCH_HINT2}.`
|
|
50128
|
+
);
|
|
50129
|
+
default:
|
|
50130
|
+
return new Error(
|
|
50131
|
+
`QueQue: OpenAI request failed (HTTP ${status}${code ? `, code ${code}` : ""}).`
|
|
50132
|
+
);
|
|
50133
|
+
}
|
|
50134
|
+
}
|
|
50135
|
+
function mapRequestFailure2(error43, timeoutMs, signal) {
|
|
50136
|
+
if (signal?.aborted) {
|
|
50137
|
+
return abortError();
|
|
50138
|
+
}
|
|
50139
|
+
const name = errorName2(error43);
|
|
50140
|
+
if (name === "TimeoutError" || name === "AbortError") {
|
|
50141
|
+
const seconds = Math.ceil(timeoutMs / 1e3);
|
|
50142
|
+
return new Error(`QueQue: OpenAI did not answer within ${seconds}s. Try ?? again.`);
|
|
50143
|
+
}
|
|
50144
|
+
if (error43 instanceof TypeError) {
|
|
50145
|
+
return new Error(
|
|
50146
|
+
`QueQue: could not reach api.openai.com. Check your connection, or ${SWITCH_HINT2}.`
|
|
50147
|
+
);
|
|
50148
|
+
}
|
|
50149
|
+
return new Error("QueQue: OpenAI request failed.");
|
|
50150
|
+
}
|
|
50151
|
+
async function fetchOpenAiCandidates(envelope, settings, timeoutMs = OPENAI_TIMEOUT_MS, options = {}) {
|
|
50152
|
+
const { signal } = options;
|
|
50153
|
+
if (signal?.aborted) {
|
|
50154
|
+
throw abortError();
|
|
50155
|
+
}
|
|
50156
|
+
const apiKey = lookupOpenAiKey();
|
|
50157
|
+
if (!apiKey) {
|
|
50158
|
+
throw new Error(
|
|
50159
|
+
"QueQue: OpenAI is pinned but OPENAI_API_KEY is not set for QueQue. Export it (or add it to ~/.env.local), then run `qq init provider` to refresh the background daemon."
|
|
50160
|
+
);
|
|
50161
|
+
}
|
|
50162
|
+
if (!HEADER_SAFE_KEY.test(apiKey)) {
|
|
50163
|
+
throw new Error(
|
|
50164
|
+
"QueQue: OPENAI_API_KEY contains invalid characters (spaces, line breaks or non-ASCII). Check the key in your environment or ~/.env.local."
|
|
50165
|
+
);
|
|
50166
|
+
}
|
|
50167
|
+
const timeout = AbortSignal.timeout(timeoutMs);
|
|
50168
|
+
const requestSignal = signal ? AbortSignal.any([signal, timeout]) : timeout;
|
|
50169
|
+
const { model } = settings;
|
|
50170
|
+
const messages = [
|
|
50171
|
+
{ role: "developer", content: buildSystemPrompt(envelope) },
|
|
50172
|
+
{ role: "user", content: buildPrompt(envelope) }
|
|
50173
|
+
];
|
|
50174
|
+
let useSchema = !modelsRejectingSchema.has(model);
|
|
50175
|
+
const requestBody = (effort) => JSON.stringify({
|
|
50176
|
+
model,
|
|
50177
|
+
messages,
|
|
50178
|
+
max_completion_tokens: MAX_OUTPUT_TOKENS,
|
|
50179
|
+
...effort === void 0 ? {} : { reasoning_effort: effort },
|
|
50180
|
+
...useSchema ? {
|
|
50181
|
+
response_format: {
|
|
50182
|
+
type: "json_schema",
|
|
50183
|
+
json_schema: {
|
|
50184
|
+
name: OPENAI_RESPONSE_FORMAT_NAME,
|
|
50185
|
+
strict: true,
|
|
50186
|
+
schema: WRAPPED_CANDIDATE_LIST_JSON_SCHEMA
|
|
50187
|
+
}
|
|
50188
|
+
}
|
|
50189
|
+
} : {}
|
|
50190
|
+
});
|
|
50191
|
+
const postChat = async (effort) => {
|
|
50192
|
+
const started = Date.now();
|
|
50193
|
+
const logRequest = (status) => {
|
|
50194
|
+
void appendDebugLog("provider", "openai request", {
|
|
50195
|
+
model,
|
|
50196
|
+
status,
|
|
50197
|
+
durationMs: Date.now() - started
|
|
50198
|
+
});
|
|
50199
|
+
};
|
|
50200
|
+
let response;
|
|
50201
|
+
try {
|
|
50202
|
+
response = await fetch(OPENAI_CHAT_COMPLETIONS_URL, {
|
|
50203
|
+
method: "POST",
|
|
50204
|
+
headers: {
|
|
50205
|
+
authorization: `Bearer ${apiKey}`,
|
|
50206
|
+
"content-type": "application/json"
|
|
50207
|
+
},
|
|
50208
|
+
body: requestBody(effort),
|
|
50209
|
+
signal: requestSignal
|
|
50210
|
+
});
|
|
50211
|
+
} catch (error43) {
|
|
50212
|
+
logRequest(null);
|
|
50213
|
+
throw mapRequestFailure2(error43, timeoutMs, signal);
|
|
50214
|
+
}
|
|
50215
|
+
logRequest(response.status);
|
|
50216
|
+
if (!response.ok) {
|
|
50217
|
+
const { code, rejectsReasoningEffort, rejectsResponseFormat } = await readSafeErrorFields(response);
|
|
50218
|
+
if (response.status === 400 && rejectsReasoningEffort && effort !== void 0) {
|
|
50219
|
+
void appendDebugLog("provider", "openai reasoning_effort rejected", { model, effort });
|
|
50220
|
+
rememberRejectedEffort(model, effort);
|
|
50221
|
+
return void 0;
|
|
50222
|
+
}
|
|
50223
|
+
if (response.status === 400 && rejectsResponseFormat && useSchema) {
|
|
50224
|
+
modelsRejectingSchema.add(model);
|
|
50225
|
+
useSchema = false;
|
|
50226
|
+
void appendDebugLog("provider", "openai response_format rejected", { model });
|
|
50227
|
+
return postChat(effort);
|
|
50228
|
+
}
|
|
50229
|
+
throw statusFailure(response.status, model, code);
|
|
50230
|
+
}
|
|
50231
|
+
let raw;
|
|
50232
|
+
try {
|
|
50233
|
+
raw = await response.text();
|
|
50234
|
+
} catch (error43) {
|
|
50235
|
+
throw mapRequestFailure2(error43, timeoutMs, signal);
|
|
50236
|
+
}
|
|
50237
|
+
let body;
|
|
50238
|
+
try {
|
|
50239
|
+
body = JSON.parse(raw);
|
|
50240
|
+
} catch {
|
|
50241
|
+
throw unexpectedResponse2();
|
|
50242
|
+
}
|
|
50243
|
+
const choice = Array.isArray(body?.choices) ? body.choices[0] : void 0;
|
|
50244
|
+
const message = choice?.message;
|
|
50245
|
+
if (!message || typeof message !== "object") {
|
|
50246
|
+
throw unexpectedResponse2();
|
|
50247
|
+
}
|
|
50248
|
+
if (choice?.finish_reason === "content_filter") {
|
|
50249
|
+
throw declinedQuery();
|
|
50250
|
+
}
|
|
50251
|
+
const finishedNormally = choice?.finish_reason === "stop";
|
|
50252
|
+
const { content, refusal } = message;
|
|
50253
|
+
if (typeof content !== "string") {
|
|
50254
|
+
if (typeof refusal === "string" && refusal.trim() !== "") {
|
|
50255
|
+
throw declinedQuery();
|
|
50256
|
+
}
|
|
50257
|
+
if (finishedNormally) {
|
|
50258
|
+
throw unexpectedResponse2();
|
|
50259
|
+
}
|
|
50260
|
+
return { content: "", finishedNormally };
|
|
50261
|
+
}
|
|
50262
|
+
return { content, finishedNormally };
|
|
50263
|
+
};
|
|
50264
|
+
const firstTurn = async (efforts) => {
|
|
50265
|
+
for (const effort of efforts) {
|
|
50266
|
+
const turn = await postChat(effort);
|
|
50267
|
+
if (turn) {
|
|
50268
|
+
return { turn, effort };
|
|
50269
|
+
}
|
|
50270
|
+
}
|
|
50271
|
+
throw unexpectedResponse2();
|
|
50272
|
+
};
|
|
50273
|
+
const knownRejection = modelsRejectingDefaultEffort.has(model);
|
|
50274
|
+
const firstEfforts = knownRejection ? [void 0] : [OPENAI_REASONING_EFFORT, void 0];
|
|
50275
|
+
const first = await firstTurn(firstEfforts);
|
|
50276
|
+
if (first.effort === void 0 && firstEfforts[0] === OPENAI_REASONING_EFFORT) {
|
|
50277
|
+
modelsRejectingDefaultEffort.add(model);
|
|
50278
|
+
}
|
|
50279
|
+
const rejectedEfforts = rejectedEffortsByModel.get(model);
|
|
50280
|
+
const retryEfforts = first.effort === OPENAI_REASONING_EFFORT ? [
|
|
50281
|
+
...OPENAI_RETRY_REASONING_EFFORTS.filter((effort) => !rejectedEfforts?.has(effort)),
|
|
50282
|
+
void 0
|
|
50283
|
+
] : [void 0];
|
|
50284
|
+
const retry = async () => (await firstTurn(retryEfforts)).turn;
|
|
50285
|
+
try {
|
|
50286
|
+
return ensureSelectableCandidates(
|
|
50287
|
+
stripTerminalControls(await candidatesWithCutOffRetry(first.turn, retry, { model }, timeout))
|
|
50288
|
+
);
|
|
50289
|
+
} catch (error43) {
|
|
50290
|
+
if (error43 instanceof Error && error43.message === TRUNCATED_RESPONSE_MESSAGE) {
|
|
50291
|
+
throw new Error(
|
|
50292
|
+
"QueQue: OpenAI response was cut off before a full command. Try ?? again, or run `qq init provider` to pick another model."
|
|
50293
|
+
);
|
|
50294
|
+
}
|
|
50295
|
+
if (error43 instanceof Error && error43.message === UNPARSEABLE_RESPONSE_MESSAGE) {
|
|
50296
|
+
throw unexpectedResponse2();
|
|
50297
|
+
}
|
|
50298
|
+
throw error43;
|
|
50299
|
+
}
|
|
50300
|
+
}
|
|
50301
|
+
var openaiAdapter = {
|
|
50302
|
+
fetchCandidates(envelope, options) {
|
|
50303
|
+
const state = loadProviderPin();
|
|
50304
|
+
if (state.kind !== "pinned" || state.pin.provider !== "openai") {
|
|
50305
|
+
return Promise.reject(
|
|
50306
|
+
new Error("QueQue: OpenAI is not the pinned provider. Run `qq init provider`.")
|
|
50307
|
+
);
|
|
50308
|
+
}
|
|
50309
|
+
return fetchOpenAiCandidates(
|
|
50310
|
+
envelope,
|
|
50311
|
+
{ model: state.pin.model ?? OPENAI_DEFAULT_MODEL },
|
|
50312
|
+
OPENAI_TIMEOUT_MS,
|
|
50313
|
+
options
|
|
50314
|
+
);
|
|
50315
|
+
}
|
|
50316
|
+
};
|
|
50317
|
+
|
|
50318
|
+
// src/registry/context-providers.ts
|
|
49507
50319
|
var registry3 = /* @__PURE__ */ new Map();
|
|
49508
|
-
function
|
|
49509
|
-
if (registry3.has(
|
|
49510
|
-
throw new Error(`
|
|
50320
|
+
function registerContextProvider(descriptor) {
|
|
50321
|
+
if (registry3.has(descriptor.id)) {
|
|
50322
|
+
throw new Error(`Context provider already registered: "${descriptor.id}"`);
|
|
49511
50323
|
}
|
|
49512
|
-
registry3.set(
|
|
50324
|
+
registry3.set(descriptor.id, descriptor);
|
|
49513
50325
|
}
|
|
49514
|
-
function
|
|
49515
|
-
return registry3.
|
|
50326
|
+
function listContextProviders() {
|
|
50327
|
+
return Array.from(registry3.values());
|
|
49516
50328
|
}
|
|
49517
50329
|
|
|
49518
50330
|
// src/registry/shell-adapters.ts
|
|
@@ -49570,6 +50382,18 @@ function bootstrapBuiltins() {
|
|
|
49570
50382
|
description: "Claude Code print-mode adapter with SDK rescue",
|
|
49571
50383
|
adapter: claudeDefaultAdapter
|
|
49572
50384
|
});
|
|
50385
|
+
registerProviderBackend({
|
|
50386
|
+
id: "ollama",
|
|
50387
|
+
name: "Ollama (local)",
|
|
50388
|
+
description: "Local Ollama /api/chat adapter \u2014 selected only by a provider.json pin",
|
|
50389
|
+
adapter: ollamaAdapter
|
|
50390
|
+
});
|
|
50391
|
+
registerProviderBackend({
|
|
50392
|
+
id: "openai",
|
|
50393
|
+
name: "OpenAI",
|
|
50394
|
+
description: "OpenAI Chat Completions adapter \u2014 selected only by a provider.json pin",
|
|
50395
|
+
adapter: openaiAdapter
|
|
50396
|
+
});
|
|
49573
50397
|
}
|
|
49574
50398
|
|
|
49575
50399
|
// src/client/run-foreground.ts
|
|
@@ -54923,10 +55747,10 @@ function _supportsColor(haveStream, { streamIsTTY, sniffFlags = true } = {}) {
|
|
|
54923
55747
|
return 3;
|
|
54924
55748
|
}
|
|
54925
55749
|
if ("TERM_PROGRAM" in env2) {
|
|
54926
|
-
const
|
|
55750
|
+
const version3 = Number.parseInt((env2.TERM_PROGRAM_VERSION || "").split(".")[0], 10);
|
|
54927
55751
|
switch (env2.TERM_PROGRAM) {
|
|
54928
55752
|
case "iTerm.app": {
|
|
54929
|
-
return
|
|
55753
|
+
return version3 >= 3 ? 3 : 2;
|
|
54930
55754
|
}
|
|
54931
55755
|
case "Apple_Terminal": {
|
|
54932
55756
|
return 2;
|
|
@@ -57342,8 +58166,8 @@ var kittyModifiers = {
|
|
|
57342
58166
|
var noop2 = () => {
|
|
57343
58167
|
};
|
|
57344
58168
|
var textEncoder = new TextEncoder();
|
|
57345
|
-
var yieldImmediate = async () => new Promise((
|
|
57346
|
-
setImmediate(
|
|
58169
|
+
var yieldImmediate = async () => new Promise((resolve5) => {
|
|
58170
|
+
setImmediate(resolve5);
|
|
57347
58171
|
});
|
|
57348
58172
|
var kittyQueryEscapeByte = 27;
|
|
57349
58173
|
var kittyQueryOpenBracketByte = 91;
|
|
@@ -57560,8 +58384,8 @@ var Ink = class {
|
|
|
57560
58384
|
};
|
|
57561
58385
|
}
|
|
57562
58386
|
this.initKittyKeyboard();
|
|
57563
|
-
this.exitPromise = new Promise((
|
|
57564
|
-
this.resolveExitPromise =
|
|
58387
|
+
this.exitPromise = new Promise((resolve5, reject) => {
|
|
58388
|
+
this.resolveExitPromise = resolve5;
|
|
57565
58389
|
this.rejectExitPromise = reject;
|
|
57566
58390
|
});
|
|
57567
58391
|
void this.exitPromise.catch(noop2);
|
|
@@ -57872,9 +58696,9 @@ var Ink = class {
|
|
|
57872
58696
|
settleThrottle(this.throttledOnRender, canWriteToStdout);
|
|
57873
58697
|
settleThrottle(this.throttledLog, canWriteToStdout);
|
|
57874
58698
|
if (canWriteToStdout && hasWritableState) {
|
|
57875
|
-
await new Promise((
|
|
58699
|
+
await new Promise((resolve5) => {
|
|
57876
58700
|
this.options.stdout.write("", () => {
|
|
57877
|
-
|
|
58701
|
+
resolve5();
|
|
57878
58702
|
});
|
|
57879
58703
|
});
|
|
57880
58704
|
return;
|
|
@@ -57960,8 +58784,8 @@ var Ink = class {
|
|
|
57960
58784
|
async awaitNextRender() {
|
|
57961
58785
|
if (!this.nextRenderCommit) {
|
|
57962
58786
|
let resolveRender;
|
|
57963
|
-
const promise2 = new Promise((
|
|
57964
|
-
resolveRender =
|
|
58787
|
+
const promise2 = new Promise((resolve5) => {
|
|
58788
|
+
resolveRender = resolve5;
|
|
57965
58789
|
});
|
|
57966
58790
|
this.nextRenderCommit = { promise: promise2, resolve: resolveRender };
|
|
57967
58791
|
}
|
|
@@ -58977,6 +59801,7 @@ async function gatherContext(request) {
|
|
|
58977
59801
|
import { execFileSync as execFileSync2, spawn as spawn2 } from "child_process";
|
|
58978
59802
|
import * as fs3 from "fs";
|
|
58979
59803
|
import * as net from "net";
|
|
59804
|
+
import { homedir as homedir4 } from "os";
|
|
58980
59805
|
import { fileURLToPath } from "url";
|
|
58981
59806
|
|
|
58982
59807
|
// src/contracts/ipc.ts
|
|
@@ -58999,6 +59824,11 @@ var ipcRequestSchema = external_exports.discriminatedUnion("kind", [
|
|
|
58999
59824
|
// The client wants one `candidate` message per parsed row before the final
|
|
59000
59825
|
// `candidates` message (Phase 09.1). Old daemons strip the key and reply once.
|
|
59001
59826
|
stream: external_exports.literal(true).optional()
|
|
59827
|
+
}),
|
|
59828
|
+
// Stop the daemon (WR-07): `qq init provider` restarts it without relying on `lsof`.
|
|
59829
|
+
// Old daemons ignore the unknown kind, so the caller falls back to signalling listeners.
|
|
59830
|
+
external_exports.object({
|
|
59831
|
+
kind: external_exports.literal("shutdown")
|
|
59002
59832
|
})
|
|
59003
59833
|
]);
|
|
59004
59834
|
var ipcResponseSchema = external_exports.discriminatedUnion("kind", [
|
|
@@ -59008,7 +59838,11 @@ var ipcResponseSchema = external_exports.discriminatedUnion("kind", [
|
|
|
59008
59838
|
// Daemon accepts envelopes carrying the `installed-tools` chunk (Phase 9).
|
|
59009
59839
|
installedTools: external_exports.literal(true).optional(),
|
|
59010
59840
|
// Daemon streams `candidate` messages to a `stream: true` request (Phase 09.1).
|
|
59011
|
-
streamCandidates: external_exports.literal(true).optional()
|
|
59841
|
+
streamCandidates: external_exports.literal(true).optional(),
|
|
59842
|
+
// Daemon resolves the adapter from provider.json on every fetch (Phase 8, 08-03).
|
|
59843
|
+
// A routing change, not an envelope shape change: a daemon without it sends every
|
|
59844
|
+
// prompt to Claude even when the user pinned a local provider.
|
|
59845
|
+
providerPin: external_exports.literal(true).optional()
|
|
59012
59846
|
}),
|
|
59013
59847
|
external_exports.object({
|
|
59014
59848
|
kind: external_exports.literal("session-ready"),
|
|
@@ -59034,6 +59868,10 @@ var ipcResponseSchema = external_exports.discriminatedUnion("kind", [
|
|
|
59034
59868
|
external_exports.object({
|
|
59035
59869
|
kind: external_exports.literal("fetch-error"),
|
|
59036
59870
|
message: external_exports.string()
|
|
59871
|
+
}),
|
|
59872
|
+
// Sent before the daemon closes its server for a `shutdown` request (WR-07).
|
|
59873
|
+
external_exports.object({
|
|
59874
|
+
kind: external_exports.literal("shutdown-accepted")
|
|
59037
59875
|
})
|
|
59038
59876
|
]);
|
|
59039
59877
|
|
|
@@ -59060,25 +59898,26 @@ var CONNECT_TIMEOUT_MS = 500;
|
|
|
59060
59898
|
var PING_TIMEOUT_MS = 500;
|
|
59061
59899
|
var POLL_INTERVAL_MS = 50;
|
|
59062
59900
|
var POLL_MAX_ATTEMPTS = 40;
|
|
59901
|
+
var SHUTDOWN_ACK_TIMEOUT_MS = 500;
|
|
59063
59902
|
function tryConnect(socketPath2) {
|
|
59064
|
-
return new Promise((
|
|
59903
|
+
return new Promise((resolve5) => {
|
|
59065
59904
|
const timer = setTimeout(() => {
|
|
59066
59905
|
client.destroy();
|
|
59067
|
-
|
|
59906
|
+
resolve5(false);
|
|
59068
59907
|
}, CONNECT_TIMEOUT_MS);
|
|
59069
59908
|
const client = net.createConnection(socketPath2, () => {
|
|
59070
59909
|
clearTimeout(timer);
|
|
59071
59910
|
client.destroy();
|
|
59072
|
-
|
|
59911
|
+
resolve5(true);
|
|
59073
59912
|
});
|
|
59074
59913
|
client.on("error", () => {
|
|
59075
59914
|
clearTimeout(timer);
|
|
59076
|
-
|
|
59915
|
+
resolve5(false);
|
|
59077
59916
|
});
|
|
59078
59917
|
});
|
|
59079
59918
|
}
|
|
59080
59919
|
function pingDaemonFetchCap(socketPath2) {
|
|
59081
|
-
return new Promise((
|
|
59920
|
+
return new Promise((resolve5) => {
|
|
59082
59921
|
let settled = false;
|
|
59083
59922
|
let buf = "";
|
|
59084
59923
|
let timer;
|
|
@@ -59091,7 +59930,7 @@ function pingDaemonFetchCap(socketPath2) {
|
|
|
59091
59930
|
clearTimeout(timer);
|
|
59092
59931
|
}
|
|
59093
59932
|
client.destroy();
|
|
59094
|
-
|
|
59933
|
+
resolve5(result);
|
|
59095
59934
|
};
|
|
59096
59935
|
const client = net.createConnection(socketPath2);
|
|
59097
59936
|
timer = setTimeout(() => {
|
|
@@ -59119,7 +59958,7 @@ function pingDaemonFetchCap(socketPath2) {
|
|
|
59119
59958
|
done("unknown");
|
|
59120
59959
|
return;
|
|
59121
59960
|
}
|
|
59122
|
-
const current2 = response.data.fetchCandidates === true && response.data.installedTools === true && response.data.streamCandidates === true;
|
|
59961
|
+
const current2 = response.data.fetchCandidates === true && response.data.installedTools === true && response.data.streamCandidates === true && response.data.providerPin === true;
|
|
59123
59962
|
done(current2 ? "yes" : "no");
|
|
59124
59963
|
});
|
|
59125
59964
|
client.on("error", () => {
|
|
@@ -59127,6 +59966,51 @@ function pingDaemonFetchCap(socketPath2) {
|
|
|
59127
59966
|
});
|
|
59128
59967
|
});
|
|
59129
59968
|
}
|
|
59969
|
+
function requestDaemonShutdown(socketPath2) {
|
|
59970
|
+
return new Promise((resolve5) => {
|
|
59971
|
+
let settled = false;
|
|
59972
|
+
let buf = "";
|
|
59973
|
+
let timer;
|
|
59974
|
+
const done = (accepted) => {
|
|
59975
|
+
if (settled) {
|
|
59976
|
+
return;
|
|
59977
|
+
}
|
|
59978
|
+
settled = true;
|
|
59979
|
+
if (timer !== void 0) {
|
|
59980
|
+
clearTimeout(timer);
|
|
59981
|
+
}
|
|
59982
|
+
client.destroy();
|
|
59983
|
+
resolve5(accepted);
|
|
59984
|
+
};
|
|
59985
|
+
const client = net.createConnection(socketPath2);
|
|
59986
|
+
timer = setTimeout(() => {
|
|
59987
|
+
done(false);
|
|
59988
|
+
}, SHUTDOWN_ACK_TIMEOUT_MS);
|
|
59989
|
+
client.on("connect", () => {
|
|
59990
|
+
client.write(`${JSON.stringify({ kind: "shutdown" })}
|
|
59991
|
+
`);
|
|
59992
|
+
});
|
|
59993
|
+
client.on("data", (chunk) => {
|
|
59994
|
+
buf += chunk.toString();
|
|
59995
|
+
const nl = buf.indexOf("\n");
|
|
59996
|
+
if (nl === -1) {
|
|
59997
|
+
return;
|
|
59998
|
+
}
|
|
59999
|
+
let parsed;
|
|
60000
|
+
try {
|
|
60001
|
+
parsed = JSON.parse(buf.slice(0, nl));
|
|
60002
|
+
} catch {
|
|
60003
|
+
done(false);
|
|
60004
|
+
return;
|
|
60005
|
+
}
|
|
60006
|
+
const response = ipcResponseSchema.safeParse(parsed);
|
|
60007
|
+
done(response.success && response.data.kind === "shutdown-accepted");
|
|
60008
|
+
});
|
|
60009
|
+
client.on("error", () => {
|
|
60010
|
+
done(false);
|
|
60011
|
+
});
|
|
60012
|
+
});
|
|
60013
|
+
}
|
|
59130
60014
|
async function waitForSocket(socketPath2, maxAttempts = POLL_MAX_ATTEMPTS) {
|
|
59131
60015
|
for (let i = 0; i < maxAttempts; i++) {
|
|
59132
60016
|
if (await tryConnect(socketPath2)) return true;
|
|
@@ -59147,10 +60031,16 @@ function listenerPids(socketPath2) {
|
|
|
59147
60031
|
}
|
|
59148
60032
|
}
|
|
59149
60033
|
function sleep2(ms) {
|
|
59150
|
-
return new Promise((
|
|
60034
|
+
return new Promise((resolve5) => setTimeout(resolve5, ms));
|
|
59151
60035
|
}
|
|
59152
60036
|
async function replaceStaleListener(socketPath2) {
|
|
59153
60037
|
void appendDebugLog("daemon", "replacing stale daemon", { socketPath: socketPath2 });
|
|
60038
|
+
if (await requestDaemonShutdown(socketPath2)) {
|
|
60039
|
+
void appendDebugLog("daemon", "daemon accepted shutdown", { socketPath: socketPath2 });
|
|
60040
|
+
for (let i = 0; i < 20 && await tryConnect(socketPath2); i++) {
|
|
60041
|
+
await sleep2(50);
|
|
60042
|
+
}
|
|
60043
|
+
}
|
|
59154
60044
|
for (const pid of listenerPids(socketPath2)) {
|
|
59155
60045
|
try {
|
|
59156
60046
|
process.kill(pid, "SIGTERM");
|
|
@@ -59188,11 +60078,30 @@ function spawnDaemon(socketPath2) {
|
|
|
59188
60078
|
}
|
|
59189
60079
|
void appendDebugLog("daemon", "spawning daemon", { qqScript, socketPath: socketPath2 });
|
|
59190
60080
|
const child = spawn2(qqBin, [qqScript, "daemon", "--socket", socketPath2], {
|
|
60081
|
+
cwd: daemonCwd(),
|
|
59191
60082
|
detached: true,
|
|
59192
60083
|
stdio: "ignore"
|
|
59193
60084
|
});
|
|
60085
|
+
child.on("error", (error43) => {
|
|
60086
|
+
void appendDebugLog("daemon", "spawn failed", { code: error43.code });
|
|
60087
|
+
});
|
|
59194
60088
|
child.unref();
|
|
59195
60089
|
}
|
|
60090
|
+
function daemonCwd() {
|
|
60091
|
+
const home = homedir4();
|
|
60092
|
+
return home && fs3.existsSync(home) ? home : "/";
|
|
60093
|
+
}
|
|
60094
|
+
async function restartDaemon(socketPath2) {
|
|
60095
|
+
assertSafeSocketPath(socketPath2);
|
|
60096
|
+
void appendDebugLog("daemon", "restart requested", { socketPath: socketPath2 });
|
|
60097
|
+
await replaceStaleListener(socketPath2);
|
|
60098
|
+
spawnDaemon(socketPath2);
|
|
60099
|
+
if (!await waitForSocket(socketPath2)) {
|
|
60100
|
+
void appendDebugLog("daemon", "restart timeout", { socketPath: socketPath2 });
|
|
60101
|
+
throw new Error("qq daemon did not restart within the expected window");
|
|
60102
|
+
}
|
|
60103
|
+
void appendDebugLog("daemon", "daemon ready", { socketPath: socketPath2, restarted: true });
|
|
60104
|
+
}
|
|
59196
60105
|
async function ensureDaemon(socketPath2) {
|
|
59197
60106
|
assertSafeSocketPath(socketPath2);
|
|
59198
60107
|
void appendDebugLog("daemon", "ensure start", { socketPath: socketPath2 });
|
|
@@ -59220,18 +60129,6 @@ async function ensureDaemon(socketPath2) {
|
|
|
59220
60129
|
|
|
59221
60130
|
// src/daemon/fetch-client.ts
|
|
59222
60131
|
import * as net2 from "net";
|
|
59223
|
-
|
|
59224
|
-
// src/providers/resolver.ts
|
|
59225
|
-
var MISSING_ADAPTER_MESSAGE = "QueQue: Claude provider is not registered \u2014 was bootstrapBuiltins() called?";
|
|
59226
|
-
function resolveClaudeDefaultAdapter() {
|
|
59227
|
-
const adapter = getProviderAdapter("claude-cli");
|
|
59228
|
-
if (!adapter) {
|
|
59229
|
-
throw new Error(MISSING_ADAPTER_MESSAGE);
|
|
59230
|
-
}
|
|
59231
|
-
return adapter;
|
|
59232
|
-
}
|
|
59233
|
-
|
|
59234
|
-
// src/daemon/fetch-client.ts
|
|
59235
60132
|
var FETCH_ACK_MS = 800;
|
|
59236
60133
|
var FETCH_TIMEOUT_MS = 26e3;
|
|
59237
60134
|
var IpcTransportError = class extends Error {
|
|
@@ -59245,7 +60142,7 @@ function requestDaemonFetch(socketPath2, envelope, timeoutMs = FETCH_TIMEOUT_MS,
|
|
|
59245
60142
|
if (signal?.aborted) {
|
|
59246
60143
|
return Promise.reject(abortError());
|
|
59247
60144
|
}
|
|
59248
|
-
return new Promise((
|
|
60145
|
+
return new Promise((resolve5, reject) => {
|
|
59249
60146
|
const client = net2.createConnection(socketPath2);
|
|
59250
60147
|
let buf = "";
|
|
59251
60148
|
let settled = false;
|
|
@@ -59266,7 +60163,7 @@ function requestDaemonFetch(socketPath2, envelope, timeoutMs = FETCH_TIMEOUT_MS,
|
|
|
59266
60163
|
reject(error43);
|
|
59267
60164
|
return;
|
|
59268
60165
|
}
|
|
59269
|
-
|
|
60166
|
+
resolve5(candidates);
|
|
59270
60167
|
};
|
|
59271
60168
|
const ackTimer = setTimeout(() => {
|
|
59272
60169
|
if (!accepted) {
|
|
@@ -59366,7 +60263,7 @@ async function fetchCandidatesForUi(socketPath2, envelope, options = {}) {
|
|
|
59366
60263
|
throw error43;
|
|
59367
60264
|
}
|
|
59368
60265
|
void appendDebugLog("client", "daemon fetch fallback", { message: error43.message });
|
|
59369
|
-
return
|
|
60266
|
+
return resolveProviderAdapter().fetchCandidates(envelope, options);
|
|
59370
60267
|
}
|
|
59371
60268
|
}
|
|
59372
60269
|
|
|
@@ -60433,7 +61330,7 @@ function CandidateSelect({
|
|
|
60433
61330
|
/* @__PURE__ */ (0, import_jsx_runtime5.jsx)(Text, { dimColor: true, children: legend.slice(MISSING_TOOL_MARK.length) })
|
|
60434
61331
|
] }),
|
|
60435
61332
|
/* @__PURE__ */ (0, import_jsx_runtime5.jsx)(ControlsLine, {}),
|
|
60436
|
-
process.env.QQ_DEV_ROOT != null && /* @__PURE__ */ (0, import_jsx_runtime5.jsx)(Box_default, { justifyContent: "flex-end", children: /* @__PURE__ */ (0, import_jsx_runtime5.jsx)(Text, { color: "yellow", children: `dev v${"0.
|
|
61333
|
+
process.env.QQ_DEV_ROOT != null && /* @__PURE__ */ (0, import_jsx_runtime5.jsx)(Box_default, { justifyContent: "flex-end", children: /* @__PURE__ */ (0, import_jsx_runtime5.jsx)(Text, { color: "yellow", children: `dev v${"0.7.0"} ${"408f7c8"}` }) })
|
|
60437
61334
|
] });
|
|
60438
61335
|
}
|
|
60439
61336
|
|
|
@@ -60711,8 +61608,14 @@ async function runForegroundClient(args) {
|
|
|
60711
61608
|
shellPid: request.shellPid
|
|
60712
61609
|
});
|
|
60713
61610
|
const toolInventory = resultMode === "llm" ? await readToolHandoff(path4.dirname(requestFile)) : null;
|
|
60714
|
-
|
|
60715
|
-
|
|
61611
|
+
try {
|
|
61612
|
+
await ensureDaemon(socketPath2);
|
|
61613
|
+
void appendDebugLog("client", "daemon ensured", { socketPath: socketPath2 });
|
|
61614
|
+
} catch (error43) {
|
|
61615
|
+
void appendDebugLog("client", "daemon ensure failed", {
|
|
61616
|
+
message: error43 instanceof Error ? error43.message : String(error43)
|
|
61617
|
+
});
|
|
61618
|
+
}
|
|
60716
61619
|
if (resultMode === "replace-buffer-fixture") {
|
|
60717
61620
|
const fixtureLbuffer = request.lbuffer || "echo hello";
|
|
60718
61621
|
await writeShellResult(resultFile, {
|
|
@@ -60780,7 +61683,7 @@ async function runForegroundClient(args) {
|
|
|
60780
61683
|
void appendDebugLog("client", "context gathered", {
|
|
60781
61684
|
extraCount: envelope.extras.length
|
|
60782
61685
|
});
|
|
60783
|
-
await new Promise((
|
|
61686
|
+
await new Promise((resolve5) => {
|
|
60784
61687
|
let unmount;
|
|
60785
61688
|
let resolved = false;
|
|
60786
61689
|
const fetchAbort = new AbortController();
|
|
@@ -60835,7 +61738,7 @@ async function runForegroundClient(args) {
|
|
|
60835
61738
|
process.off("SIGTERM", cleanupOnSignal);
|
|
60836
61739
|
app.unmount();
|
|
60837
61740
|
if (!skipClear) clearScrollReserve();
|
|
60838
|
-
|
|
61741
|
+
resolve5();
|
|
60839
61742
|
};
|
|
60840
61743
|
const onCandidate = (candidate) => {
|
|
60841
61744
|
if (resolved) return;
|
|
@@ -60929,8 +61832,8 @@ async function clientCommand(options) {
|
|
|
60929
61832
|
|
|
60930
61833
|
// src/daemon/server.ts
|
|
60931
61834
|
import * as net3 from "net";
|
|
60932
|
-
function startDaemonServer(socketPath2) {
|
|
60933
|
-
return new Promise((
|
|
61835
|
+
function startDaemonServer(socketPath2, options = {}) {
|
|
61836
|
+
return new Promise((resolve5, reject) => {
|
|
60934
61837
|
const MAX_BUF_BYTES = 256 * 1024;
|
|
60935
61838
|
const server = net3.createServer((socket) => {
|
|
60936
61839
|
let buf = "";
|
|
@@ -60975,11 +61878,25 @@ function startDaemonServer(socketPath2) {
|
|
|
60975
61878
|
kind: "pong",
|
|
60976
61879
|
fetchCandidates: true,
|
|
60977
61880
|
installedTools: true,
|
|
60978
|
-
streamCandidates: true
|
|
61881
|
+
streamCandidates: true,
|
|
61882
|
+
providerPin: true
|
|
60979
61883
|
});
|
|
60980
61884
|
void appendDebugLog("daemon", "replied pong");
|
|
60981
61885
|
break;
|
|
60982
61886
|
}
|
|
61887
|
+
case "shutdown": {
|
|
61888
|
+
const { onShutdown } = options;
|
|
61889
|
+
if (!onShutdown) {
|
|
61890
|
+
void appendDebugLog("daemon", "ignored shutdown request");
|
|
61891
|
+
break;
|
|
61892
|
+
}
|
|
61893
|
+
void appendDebugLog("daemon", "shutdown requested");
|
|
61894
|
+
socket.write(`${JSON.stringify({ kind: "shutdown-accepted" })}
|
|
61895
|
+
`, () => {
|
|
61896
|
+
onShutdown();
|
|
61897
|
+
});
|
|
61898
|
+
break;
|
|
61899
|
+
}
|
|
60983
61900
|
case "ensure-session": {
|
|
60984
61901
|
writeJson({ kind: "session-ready", socketPath: socketPath2 });
|
|
60985
61902
|
void appendDebugLog("daemon", "replied session-ready", { socketPath: socketPath2 });
|
|
@@ -61010,7 +61927,7 @@ function startDaemonServer(socketPath2) {
|
|
|
61010
61927
|
} : void 0;
|
|
61011
61928
|
void Promise.resolve().then(() => {
|
|
61012
61929
|
bootstrapBuiltins();
|
|
61013
|
-
const adapter =
|
|
61930
|
+
const adapter = resolveProviderAdapter();
|
|
61014
61931
|
return adapter.fetchCandidates(envelope, {
|
|
61015
61932
|
signal: connectionAbort.signal,
|
|
61016
61933
|
onCandidate
|
|
@@ -61047,7 +61964,7 @@ function startDaemonServer(socketPath2) {
|
|
|
61047
61964
|
server.on("error", reject);
|
|
61048
61965
|
server.listen(socketPath2, () => {
|
|
61049
61966
|
void appendDebugLog("daemon", "listening", { socketPath: socketPath2 });
|
|
61050
|
-
|
|
61967
|
+
resolve5(server);
|
|
61051
61968
|
});
|
|
61052
61969
|
});
|
|
61053
61970
|
}
|
|
@@ -61087,7 +62004,8 @@ async function daemonCommand(options) {
|
|
|
61087
62004
|
void appendDebugLog("daemon", "ensure command complete", { socket: sock });
|
|
61088
62005
|
return;
|
|
61089
62006
|
}
|
|
61090
|
-
|
|
62007
|
+
let onShutdownRequest = () => void 0;
|
|
62008
|
+
const server = await startDaemonServer(sock, { onShutdown: () => onShutdownRequest() });
|
|
61091
62009
|
const connections = trackConnections(server);
|
|
61092
62010
|
void appendDebugLog("daemon", "server started", { socket: sock });
|
|
61093
62011
|
enablePrewarm();
|
|
@@ -61095,25 +62013,33 @@ async function daemonCommand(options) {
|
|
|
61095
62013
|
void appendDebugLog("daemon", "shutdown", { socket: sock, inFlight: connections.size });
|
|
61096
62014
|
shutdownDaemon(server, connections);
|
|
61097
62015
|
};
|
|
62016
|
+
onShutdownRequest = shutdown;
|
|
61098
62017
|
process.once("SIGTERM", shutdown);
|
|
61099
62018
|
process.once("SIGINT", shutdown);
|
|
61100
62019
|
await new Promise(() => {
|
|
61101
62020
|
});
|
|
61102
62021
|
}
|
|
61103
62022
|
|
|
62023
|
+
// src/cli/commands/init-provider.ts
|
|
62024
|
+
import { spawn as spawn4 } from "child_process";
|
|
62025
|
+
import { closeSync, openSync } from "fs";
|
|
62026
|
+
import { homedir as homedir6 } from "os";
|
|
62027
|
+
import { createInterface } from "readline";
|
|
62028
|
+
import * as tty4 from "tty";
|
|
62029
|
+
|
|
61104
62030
|
// src/cli/commands/init.ts
|
|
61105
|
-
import { appendFileSync, existsSync as existsSync4, readFileSync as
|
|
61106
|
-
import { homedir as
|
|
61107
|
-
import { dirname as
|
|
62031
|
+
import { appendFileSync, existsSync as existsSync4, readFileSync as readFileSync5 } from "fs";
|
|
62032
|
+
import { homedir as homedir5 } from "os";
|
|
62033
|
+
import { dirname as dirname5, join as join5, resolve as resolve4 } from "path";
|
|
61108
62034
|
import { fileURLToPath as fileURLToPath2 } from "url";
|
|
61109
|
-
var __dirname =
|
|
62035
|
+
var __dirname = dirname5(fileURLToPath2(import.meta.url));
|
|
61110
62036
|
var HOMEBREW_PREFIXES = ["/opt/homebrew", "/usr/local", "/home/linuxbrew/.linuxbrew"];
|
|
61111
62037
|
function _resolveScriptPath(shell) {
|
|
61112
62038
|
for (const prefix of HOMEBREW_PREFIXES) {
|
|
61113
|
-
const p =
|
|
62039
|
+
const p = resolve4(prefix, "share", "queque", `queque.${shell}`);
|
|
61114
62040
|
if (existsSync4(p)) return p;
|
|
61115
62041
|
}
|
|
61116
|
-
return
|
|
62042
|
+
return resolve4(__dirname, "../../shell", shell, `queque.${shell}`);
|
|
61117
62043
|
}
|
|
61118
62044
|
function hasShellIntegration(existing, shell) {
|
|
61119
62045
|
if (/# queque shell integration/.test(existing)) {
|
|
@@ -61129,10 +62055,10 @@ function initCommand(shell) {
|
|
|
61129
62055
|
console.error(`Unsupported shell: '${shell}'. Supported: ${supportedShells.join(", ")}`);
|
|
61130
62056
|
process.exit(1);
|
|
61131
62057
|
}
|
|
61132
|
-
const zshrc =
|
|
62058
|
+
const zshrc = join5(homedir5(), ".zshrc");
|
|
61133
62059
|
const scriptPath = _resolveScriptPath(shell);
|
|
61134
62060
|
const snippet = `source "${scriptPath}"`;
|
|
61135
|
-
const existing = existsSync4(zshrc) ?
|
|
62061
|
+
const existing = existsSync4(zshrc) ? readFileSync5(zshrc, "utf8") : "";
|
|
61136
62062
|
if (hasShellIntegration(existing, shell)) {
|
|
61137
62063
|
console.error("queque: shell integration already present in ~/.zshrc");
|
|
61138
62064
|
process.exit(0);
|
|
@@ -61144,6 +62070,306 @@ ${snippet}
|
|
|
61144
62070
|
console.log("queque: added shell integration to ~/.zshrc \u2014 run: source ~/.zshrc");
|
|
61145
62071
|
}
|
|
61146
62072
|
|
|
62073
|
+
// src/cli/commands/init-provider.ts
|
|
62074
|
+
var PROVIDER_MENU = [
|
|
62075
|
+
{
|
|
62076
|
+
id: "claude",
|
|
62077
|
+
label: "Claude",
|
|
62078
|
+
hint: "Claude Code (`claude /login`) or ANTHROPIC_API_KEY"
|
|
62079
|
+
},
|
|
62080
|
+
{ id: "openai", label: "OpenAI (beta)", hint: "uses OPENAI_API_KEY" },
|
|
62081
|
+
{ id: "ollama", label: "Ollama (beta)", hint: "local models on this machine" }
|
|
62082
|
+
];
|
|
62083
|
+
var MENU_LABEL_WIDTH = Math.max(...PROVIDER_MENU.map((entry) => entry.label.length));
|
|
62084
|
+
var OLLAMA_DOWNLOAD_URL = "https://ollama.com/download";
|
|
62085
|
+
var MAX_ATTEMPTS = 3;
|
|
62086
|
+
var MAX_REASON = 120;
|
|
62087
|
+
var NO_CHANGES = "No changes made.";
|
|
62088
|
+
var CLAUDE_AUTH_HINT = "If ?? says Claude is not authenticated, run `claude /login` or set ANTHROPIC_API_KEY (docs: https://code.claude.com/docs/en/authentication).";
|
|
62089
|
+
var OPENAI_KEY_MISSING = "OPENAI_API_KEY is not set. Add `export OPENAI_API_KEY=...` to ~/.zshrc (before the queque source line) or put it in ~/.env.local, open a new terminal, and run `qq init provider` again.";
|
|
62090
|
+
function openDownloadUrl(url2) {
|
|
62091
|
+
if (url2 !== OLLAMA_DOWNLOAD_URL) {
|
|
62092
|
+
return;
|
|
62093
|
+
}
|
|
62094
|
+
const opener = process.platform === "darwin" ? "open" : "xdg-open";
|
|
62095
|
+
try {
|
|
62096
|
+
const child = spawn4(opener, [url2], { stdio: "ignore", detached: true });
|
|
62097
|
+
child.on("error", () => void 0);
|
|
62098
|
+
child.unref();
|
|
62099
|
+
} catch {
|
|
62100
|
+
}
|
|
62101
|
+
}
|
|
62102
|
+
var defaultDeps = {
|
|
62103
|
+
openUrl: openDownloadUrl,
|
|
62104
|
+
restartDaemon: (path5) => restartDaemon(path5),
|
|
62105
|
+
listOllamaModels: (baseUrl) => listOllamaModels(baseUrl)
|
|
62106
|
+
};
|
|
62107
|
+
function shortReason(error43) {
|
|
62108
|
+
const code = error43?.code;
|
|
62109
|
+
const message = error43 instanceof Error ? error43.message : String(error43);
|
|
62110
|
+
const flat = (typeof code === "string" ? code : message).replace(/\s+/g, " ").trim();
|
|
62111
|
+
return flat.length > MAX_REASON ? `${flat.slice(0, MAX_REASON)}\u2026` : flat;
|
|
62112
|
+
}
|
|
62113
|
+
function choiceHint(count) {
|
|
62114
|
+
if (count === 1) {
|
|
62115
|
+
return "Choose 1.";
|
|
62116
|
+
}
|
|
62117
|
+
if (count === 2) {
|
|
62118
|
+
return "Choose 1 or 2.";
|
|
62119
|
+
}
|
|
62120
|
+
if (count === 3) {
|
|
62121
|
+
return "Choose 1, 2, or 3.";
|
|
62122
|
+
}
|
|
62123
|
+
return `Choose a number from 1 to ${count}.`;
|
|
62124
|
+
}
|
|
62125
|
+
var Prompter = class {
|
|
62126
|
+
constructor(io) {
|
|
62127
|
+
this.io = io;
|
|
62128
|
+
this.rl = createInterface({
|
|
62129
|
+
input: io.input,
|
|
62130
|
+
terminal: false,
|
|
62131
|
+
crlfDelay: Number.POSITIVE_INFINITY
|
|
62132
|
+
});
|
|
62133
|
+
this.lines = this.rl[Symbol.asyncIterator]();
|
|
62134
|
+
}
|
|
62135
|
+
io;
|
|
62136
|
+
rl;
|
|
62137
|
+
lines;
|
|
62138
|
+
say(line) {
|
|
62139
|
+
this.io.output.write(`${line}
|
|
62140
|
+
`);
|
|
62141
|
+
}
|
|
62142
|
+
/** The trimmed answer, or null when the input ended (or closed) first. */
|
|
62143
|
+
async ask(prompt) {
|
|
62144
|
+
this.io.output.write(prompt);
|
|
62145
|
+
try {
|
|
62146
|
+
const next = await this.lines.next();
|
|
62147
|
+
return next.done ? null : String(next.value).trim();
|
|
62148
|
+
} catch {
|
|
62149
|
+
return null;
|
|
62150
|
+
}
|
|
62151
|
+
}
|
|
62152
|
+
/** A 1-based choice where Enter picks 1; re-asks up to MAX_ATTEMPTS times. */
|
|
62153
|
+
async choose(prompt, count) {
|
|
62154
|
+
for (let attempt = 0; attempt < MAX_ATTEMPTS; attempt++) {
|
|
62155
|
+
const answer = await this.ask(prompt);
|
|
62156
|
+
if (answer === null) {
|
|
62157
|
+
return { kind: "eof" };
|
|
62158
|
+
}
|
|
62159
|
+
if (answer === "") {
|
|
62160
|
+
return { kind: "choice", value: 1 };
|
|
62161
|
+
}
|
|
62162
|
+
const value = /^\d+$/.test(answer) ? Number.parseInt(answer, 10) : Number.NaN;
|
|
62163
|
+
if (value >= 1 && value <= count) {
|
|
62164
|
+
return { kind: "choice", value };
|
|
62165
|
+
}
|
|
62166
|
+
this.say(choiceHint(count));
|
|
62167
|
+
}
|
|
62168
|
+
return { kind: "invalid" };
|
|
62169
|
+
}
|
|
62170
|
+
close() {
|
|
62171
|
+
this.rl.close();
|
|
62172
|
+
}
|
|
62173
|
+
};
|
|
62174
|
+
function describeCurrent(prompter, state) {
|
|
62175
|
+
if (state.kind === "pinned") {
|
|
62176
|
+
const { pin } = state;
|
|
62177
|
+
const model = "model" in pin && pin.model ? ` (${pin.model})` : "";
|
|
62178
|
+
prompter.say(`Current: ${pin.provider}${model}`);
|
|
62179
|
+
} else if (state.kind === "invalid") {
|
|
62180
|
+
prompter.say("Current provider.json is invalid; your choice below replaces it.");
|
|
62181
|
+
}
|
|
62182
|
+
}
|
|
62183
|
+
function openAiKeyPresent() {
|
|
62184
|
+
return (usableSecret(process.env.OPENAI_API_KEY) ?? usableSecret(readEnvValueFromDotEnvLocal("OPENAI_API_KEY", homedir6()))) !== void 0;
|
|
62185
|
+
}
|
|
62186
|
+
function keptPinFields(state) {
|
|
62187
|
+
if (state.kind !== "pinned") {
|
|
62188
|
+
return {};
|
|
62189
|
+
}
|
|
62190
|
+
const { pin } = state;
|
|
62191
|
+
if (pin.provider === "ollama" && pin.baseUrl) {
|
|
62192
|
+
return { ollamaBaseUrl: pin.baseUrl };
|
|
62193
|
+
}
|
|
62194
|
+
if (pin.provider === "openai" && pin.model) {
|
|
62195
|
+
return { openAiModel: pin.model };
|
|
62196
|
+
}
|
|
62197
|
+
return {};
|
|
62198
|
+
}
|
|
62199
|
+
async function explainOllamaDown(prompter, deps, baseUrl, savedBaseUrl) {
|
|
62200
|
+
prompter.say(`Ollama is not answering at ${baseUrl}.`);
|
|
62201
|
+
if (savedBaseUrl) {
|
|
62202
|
+
prompter.say(
|
|
62203
|
+
`Check that the Ollama server at ${baseUrl} is running, or remove "baseUrl" from ${providerPinPath()} to use Ollama on this machine, then run \`qq init provider\` again.`
|
|
62204
|
+
);
|
|
62205
|
+
return;
|
|
62206
|
+
}
|
|
62207
|
+
prompter.say(
|
|
62208
|
+
`Install it from ${OLLAMA_DOWNLOAD_URL}, start it with \`ollama serve\`, then run \`qq init provider\` again.`
|
|
62209
|
+
);
|
|
62210
|
+
const answer = await prompter.ask(`Open ${OLLAMA_DOWNLOAD_URL} in your browser? [y/N]: `);
|
|
62211
|
+
if (answer !== null && /^(y|yes)$/i.test(answer)) {
|
|
62212
|
+
deps.openUrl(OLLAMA_DOWNLOAD_URL);
|
|
62213
|
+
}
|
|
62214
|
+
}
|
|
62215
|
+
async function pickOllamaModel(prompter, deps, savedBaseUrl) {
|
|
62216
|
+
const baseUrl = savedBaseUrl ?? OLLAMA_DEFAULT_BASE_URL;
|
|
62217
|
+
const listed = await deps.listOllamaModels(baseUrl);
|
|
62218
|
+
if (!listed.ok) {
|
|
62219
|
+
await explainOllamaDown(prompter, deps, baseUrl, savedBaseUrl !== void 0);
|
|
62220
|
+
return null;
|
|
62221
|
+
}
|
|
62222
|
+
const { models } = listed;
|
|
62223
|
+
if (models.length === 0) {
|
|
62224
|
+
prompter.say(
|
|
62225
|
+
"Ollama is running but has no models. Run `ollama pull gemma4` (or any model), then run `qq init provider` again."
|
|
62226
|
+
);
|
|
62227
|
+
return null;
|
|
62228
|
+
}
|
|
62229
|
+
prompter.say("Installed Ollama models:");
|
|
62230
|
+
models.forEach((model, index) => {
|
|
62231
|
+
prompter.say(` ${index + 1}. ${model}`);
|
|
62232
|
+
});
|
|
62233
|
+
const choice = await prompter.choose(`Model 1-${models.length} [1]: `, models.length);
|
|
62234
|
+
if (choice.kind !== "choice") {
|
|
62235
|
+
prompter.say(NO_CHANGES);
|
|
62236
|
+
return null;
|
|
62237
|
+
}
|
|
62238
|
+
return models[choice.value - 1];
|
|
62239
|
+
}
|
|
62240
|
+
function savePin(prompter, pin) {
|
|
62241
|
+
try {
|
|
62242
|
+
return writeProviderPin(pin);
|
|
62243
|
+
} catch (error43) {
|
|
62244
|
+
prompter.say(`Could not save ${providerPinPath()} (${shortReason(error43)}). ${NO_CHANGES}`);
|
|
62245
|
+
return null;
|
|
62246
|
+
}
|
|
62247
|
+
}
|
|
62248
|
+
async function refreshDaemon(prompter, deps) {
|
|
62249
|
+
try {
|
|
62250
|
+
await deps.restartDaemon(socketPath());
|
|
62251
|
+
prompter.say(
|
|
62252
|
+
"Restarted the QueQue daemon so the next ?? uses this provider and your current environment."
|
|
62253
|
+
);
|
|
62254
|
+
} catch (error43) {
|
|
62255
|
+
prompter.say(
|
|
62256
|
+
`Pin saved, but the QueQue daemon could not restart (${shortReason(error43)}). Open a new terminal before the next ??.`
|
|
62257
|
+
);
|
|
62258
|
+
}
|
|
62259
|
+
}
|
|
62260
|
+
async function pickAndSave(prompter, deps) {
|
|
62261
|
+
prompter.say("QueQue provider setup");
|
|
62262
|
+
const current2 = loadProviderPin();
|
|
62263
|
+
describeCurrent(prompter, current2);
|
|
62264
|
+
const kept = keptPinFields(current2);
|
|
62265
|
+
PROVIDER_MENU.forEach((entry, index) => {
|
|
62266
|
+
prompter.say(` ${index + 1}. ${entry.label.padEnd(MENU_LABEL_WIDTH)} ${entry.hint}`);
|
|
62267
|
+
});
|
|
62268
|
+
const choice = await prompter.choose(
|
|
62269
|
+
`Choose 1-${PROVIDER_MENU.length} [1]: `,
|
|
62270
|
+
PROVIDER_MENU.length
|
|
62271
|
+
);
|
|
62272
|
+
if (choice.kind !== "choice") {
|
|
62273
|
+
prompter.say(NO_CHANGES);
|
|
62274
|
+
return 1;
|
|
62275
|
+
}
|
|
62276
|
+
const provider = PROVIDER_MENU[choice.value - 1].id;
|
|
62277
|
+
if (provider === "claude") {
|
|
62278
|
+
const path5 = savePin(prompter, { version: 1, provider: "claude" });
|
|
62279
|
+
if (path5 === null) {
|
|
62280
|
+
return 1;
|
|
62281
|
+
}
|
|
62282
|
+
prompter.say(`Saved ${path5}: Claude.`);
|
|
62283
|
+
prompter.say(CLAUDE_AUTH_HINT);
|
|
62284
|
+
} else if (provider === "openai") {
|
|
62285
|
+
if (!openAiKeyPresent()) {
|
|
62286
|
+
prompter.say(OPENAI_KEY_MISSING);
|
|
62287
|
+
return 1;
|
|
62288
|
+
}
|
|
62289
|
+
const { openAiModel } = kept;
|
|
62290
|
+
const path5 = savePin(prompter, {
|
|
62291
|
+
version: 1,
|
|
62292
|
+
provider: "openai",
|
|
62293
|
+
...openAiModel ? { model: openAiModel } : {}
|
|
62294
|
+
});
|
|
62295
|
+
if (path5 === null) {
|
|
62296
|
+
return 1;
|
|
62297
|
+
}
|
|
62298
|
+
prompter.say(
|
|
62299
|
+
openAiModel ? `Saved ${path5}: OpenAI (kept model ${openAiModel}).` : `Saved ${path5}: OpenAI (default model; add "model" to provider.json to change it).`
|
|
62300
|
+
);
|
|
62301
|
+
} else {
|
|
62302
|
+
const { ollamaBaseUrl } = kept;
|
|
62303
|
+
const model = await pickOllamaModel(prompter, deps, ollamaBaseUrl);
|
|
62304
|
+
if (model === null) {
|
|
62305
|
+
return 1;
|
|
62306
|
+
}
|
|
62307
|
+
const path5 = savePin(prompter, {
|
|
62308
|
+
version: 1,
|
|
62309
|
+
provider: "ollama",
|
|
62310
|
+
model,
|
|
62311
|
+
...ollamaBaseUrl ? { baseUrl: ollamaBaseUrl } : {}
|
|
62312
|
+
});
|
|
62313
|
+
if (path5 === null) {
|
|
62314
|
+
return 1;
|
|
62315
|
+
}
|
|
62316
|
+
prompter.say(
|
|
62317
|
+
ollamaBaseUrl ? `Saved ${path5}: Ollama (${model}) at ${ollamaBaseUrl}.` : `Saved ${path5}: Ollama (${model}). Using a remote Ollama? Add "baseUrl" to provider.json.`
|
|
62318
|
+
);
|
|
62319
|
+
}
|
|
62320
|
+
await refreshDaemon(prompter, deps);
|
|
62321
|
+
return 0;
|
|
62322
|
+
}
|
|
62323
|
+
async function runProviderPicker(io, deps = {}) {
|
|
62324
|
+
const prompter = new Prompter(io);
|
|
62325
|
+
try {
|
|
62326
|
+
return await pickAndSave(prompter, { ...defaultDeps, ...deps });
|
|
62327
|
+
} finally {
|
|
62328
|
+
prompter.close();
|
|
62329
|
+
}
|
|
62330
|
+
}
|
|
62331
|
+
function endStream(stream) {
|
|
62332
|
+
return new Promise((resolve5) => {
|
|
62333
|
+
stream.end(() => resolve5());
|
|
62334
|
+
});
|
|
62335
|
+
}
|
|
62336
|
+
function openTerminal() {
|
|
62337
|
+
let inFd;
|
|
62338
|
+
try {
|
|
62339
|
+
inFd = openSync("/dev/tty", "r");
|
|
62340
|
+
return { inFd, outFd: openSync("/dev/tty", "w") };
|
|
62341
|
+
} catch {
|
|
62342
|
+
if (inFd !== void 0) {
|
|
62343
|
+
closeSync(inFd);
|
|
62344
|
+
}
|
|
62345
|
+
return null;
|
|
62346
|
+
}
|
|
62347
|
+
}
|
|
62348
|
+
async function providerInitCommand() {
|
|
62349
|
+
const terminal = openTerminal();
|
|
62350
|
+
if (terminal === null) {
|
|
62351
|
+
console.error("qq init provider needs an interactive terminal (/dev/tty).");
|
|
62352
|
+
process.exitCode = 1;
|
|
62353
|
+
return;
|
|
62354
|
+
}
|
|
62355
|
+
const input = new tty4.ReadStream(terminal.inFd);
|
|
62356
|
+
const output = new tty4.WriteStream(terminal.outFd);
|
|
62357
|
+
try {
|
|
62358
|
+
process.exitCode = await runProviderPicker({ input, output });
|
|
62359
|
+
} finally {
|
|
62360
|
+
input.destroy();
|
|
62361
|
+
await endStream(output);
|
|
62362
|
+
output.destroy();
|
|
62363
|
+
}
|
|
62364
|
+
}
|
|
62365
|
+
async function dispatchInit(shell, handlers = { provider: providerInitCommand, shell: initCommand }) {
|
|
62366
|
+
if (shell === "provider") {
|
|
62367
|
+
await handlers.provider();
|
|
62368
|
+
return;
|
|
62369
|
+
}
|
|
62370
|
+
handlers.shell(shell);
|
|
62371
|
+
}
|
|
62372
|
+
|
|
61147
62373
|
// src/cli/main.ts
|
|
61148
62374
|
function requiredOption(name, value) {
|
|
61149
62375
|
if (!value) {
|
|
@@ -61186,9 +62412,9 @@ async function main(argv = process.argv.slice(2)) {
|
|
|
61186
62412
|
});
|
|
61187
62413
|
cli.command(
|
|
61188
62414
|
"init <shell>",
|
|
61189
|
-
"Add shell integration to ~/.zshrc (
|
|
61190
|
-
).action((shell) => {
|
|
61191
|
-
|
|
62415
|
+
"Add shell integration to ~/.zshrc (`qq init zsh && source ~/.zshrc`), or run `qq init provider` to pick OpenAI or Ollama"
|
|
62416
|
+
).action(async (shell) => {
|
|
62417
|
+
await dispatchInit(shell);
|
|
61192
62418
|
});
|
|
61193
62419
|
cli.command("daemon").option("--socket <path>", "Unix socket path for the daemon").option("--ensure", "Ensure the daemon is running before returning").action(async (options) => {
|
|
61194
62420
|
await daemonCommand(options);
|