@crewx/sdk 0.9.0-rc.9 → 0.9.0-rc.91

package/dist/plugins/sqlite-tracing.d.ts

@@ -1,5 +1,18 @@
 import { CrewxPlugin } from '../plugin';
 import type { Crewx } from '../facade/Crewx';
+export interface SqliteTracingMetrics {
+    flushCount: number;
+    flushedEntries: number;
+    maxQueueEntries: number;
+    maxQueueBytes: number;
+    appendFailureCount: number;
+    appendFailureEntries: number;
+    appendFailureBytes: number;
+    appendFailureByCode: Record<string, number>;
+    appendFailureByCause: Record<string, number>;
+    pendingQueueEntries: number;
+    pendingQueueBytes: number;
+}
 export interface SqliteTracingPluginOptions {
     dbRoot?: string;
     version?: string;
@@ -9,7 +22,17 @@ export declare class SqliteTracingPlugin extends CrewxPlugin {
     private unsubs;
     private readonly dbPath;
     private readonly version;
+    private taskRepo?;
+    private readonly queues;
+    private metrics;
     constructor(opts?: SqliteTracingPluginOptions);
     attach(crewx: Crewx): void;
     detach(_crewx: Crewx): void;
+    getMetrics(): SqliteTracingMetrics;
+    private enqueueLog;
+    private recoverPartialResult;
+    private flushTaskLogs;
+    private flushAllTaskLogs;
+    private clearAllTimers;
+    private recordAppendFailure;
 }

package/dist/provider/acp/connection.d.ts

@@ -6,6 +6,7 @@ export interface AcpConnectionOptions {
     env?: Record<string, string>;
     cwd?: string;
     timeoutMs?: number;
+    idleMs?: number;
     onStderr?: (line: string) => void;
     onPid?: (pid: number) => void;
     configOptions?: Record<string, string>;
@@ -17,7 +18,12 @@ export declare class AcpConnection {
     private disposed;
     private stderrBuffer;
     private collectedStderr;
+    private stderrDecoder;
+    private stderrDecodeChain;
     private pendingUpdateCallback;
+    private idleWatchdog;
+    private idleReject;
+    private idlePromise;
     private authMethods;
     private _initResponse;
     get initResponse(): InitializeResponse | null;

package/dist/provider/acp/meta.d.ts

@@ -1,3 +1,7 @@
+import type { ProviderDefaultProfile } from '../models.js';
+import type { ProviderOptionSpec } from '../models.js';
+import type { ModelTier } from '../../config/models.generated.js';
+import type { ModelApiPricing } from '../../config/pricing.types.js';
 import type { InitializeResponse, NewSessionResponse } from './types.js';
 export interface AcpProviderMetaResult {
     id: string;
@@ -11,11 +15,18 @@ export interface AcpProviderMetaResult {
     models: Array<{
         id: string;
         name?: string;
+        description?: string;
+        contextWindowTokens?: number;
+        tier?: ModelTier;
+        recommended?: boolean;
+        apiPricing?: ModelApiPricing;
     }>;
     modelOverrides?: Record<string, {
         effort?: string[];
         defaultEffort?: string;
     }>;
+    providerOptions?: ProviderOptionSpec[];
+    defaults?: ProviderDefaultProfile;
     capabilities: Record<string, boolean>;
 }
 declare function extractProviderMeta(adapterId: string, displayName: string | undefined, initResponse: InitializeResponse, sessionResponse: NewSessionResponse): AcpProviderMetaResult;

package/dist/provider/bridge.d.ts

@@ -3,8 +3,10 @@ export declare function parseStreamJsonOutput(raw: string): string;
 export declare function parseResultEventUsage(raw: string): ProviderUsage | null;
 export { ProviderError, IdleTimeoutError, TotalTimeoutError, type ProviderErrorCode, type ProviderErrorKind, type ProviderErrorOptions, } from './errors.js';
 export declare function shouldFallbackToGhCopilot(providerId: string, err: unknown, platform?: NodeJS.Platform): boolean;
+export declare const KILL_GRACE_MS = 2000;
 export interface RunCliProcessOptions {
     timeoutMs?: number;
+    idleMs?: number;
     env?: Record<string, string>;
     cwd?: string;
     onOutput?: (line: string, level: 'stdout' | 'stderr') => void;
@@ -53,10 +55,13 @@ export interface ProviderQueryOptions {
     model?: string;
     effort?: string;
     mode?: string;
+    providerOptions?: Record<string, unknown>;
     context?: string;
     systemPrompt?: string;
     additionalArgs?: string[];
     resumeSessionId?: string;
+    providerSessionId?: string;
+    onProviderSessionId?: (id: string) => void;
     onOutput?: (line: string, level: 'stdout' | 'stderr') => void;
     onPid?: (pid: number) => void;
     onCommand?: (command: string) => void;
@@ -67,6 +72,7 @@ export interface ProviderQueryOptions {
     env?: Record<string, string>;
     cwd?: string;
     timeoutMs?: number;
+    idleMs?: number;
     configOptions?: Record<string, string>;
     tools?: import('../facade/Crewx').ToolDefinition[];
     maxSteps?: number;

package/dist/provider/classify-task-error.d.ts

@@ -0,0 +1,2 @@
+import type { TaskErrorProjection } from './task-error.types.js';
+export declare function classifyTaskError(input: unknown): TaskErrorProjection;

package/dist/provider/cli/adapter.types.d.ts

@@ -1,18 +1,24 @@
 import type { ProviderQueryOptions, ProviderUsage } from '../bridge.js';
 import type { TaskLogEntry } from '../../types/task-log.types.js';
+import type { ModelTier } from '../../config/models.generated.js';
 import { ProviderError } from '../errors.js';
 export interface CliProviderAdapter {
     readonly command: string;
+    createSessionId?(): string;
     readonly meta?: {
         displayName?: string;
         models?: Array<{
             id: string;
             name?: string;
+            description?: string;
+            contextWindowTokens?: number;
+            tier?: ModelTier;
         }>;
         defaultTimeoutMs?: {
             query?: number;
             execute?: number;
         };
+        defaultIdleMs?: number;
         capabilities?: {
             resume?: boolean;
             image?: boolean;
@@ -27,8 +33,9 @@ export interface CliProviderAdapter {
         env?: Record<string, string>;
     };
     extractText(stdout: string): string;
+    extractPartialText?(stdout: string): string | undefined;
     extractFailure?(line: string): Error | null;
-    interpretExit?(code: number, stderr: string): Error | null;
+    interpretExit?(code: number, stderr: string, stdout?: string): Error | null;
     parseResultMeta?(stdout: string): {
         usage?: ProviderUsage | null;
         model?: string | null;

package/dist/provider/cli/adapters/agent-call.util.d.ts

@@ -1,3 +1,3 @@
 import type { TaskLogEntry } from '../../../types/task-log.types';
 export declare function isAgentCallCommand(command: string): boolean;
-export declare function parseAgentCall(timestamp: string, command: string): TaskLogEntry;
+export declare function parseAgentCall(timestamp: string, command: string, toolUseId?: string): TaskLogEntry;

package/dist/provider/cli/adapters/cli-knob.util.d.ts

@@ -6,3 +6,10 @@ export declare function codexModeArgs(mode?: string): string[];
 export declare function codexResumeModeArgs(mode?: string): string[];
 export declare function codexEffortArgs(effort?: string): string[];
 export declare function claudeModeArgs(mode?: string): string[];
+export declare function claudeEffortArgs(effort?: string): string[];
+export declare function grokModeArgs(mode?: string): string[];
+export declare function grokAlwaysApproveArgs(alwaysApprove?: unknown): string[];
+export declare function grokSandboxArgs(sandbox?: unknown, onWarning?: (message: string) => void): string[];
+export declare function grokEffortArgs(effort?: string): string[];
+export declare function antigravityModeArgs(mode?: string): string[];
+export declare function antigravityEffortArgs(effort?: string): string[];

package/dist/provider/cli/adapters/grok.d.ts

@@ -0,0 +1,2 @@
+import type { CliProviderAdapter } from '../adapter.types.js';
+export declare const grokAdapter: CliProviderAdapter;

package/dist/provider/cli/adapters/index.d.ts

@@ -5,6 +5,7 @@ export { copilotAdapter } from './copilot.js';
 export { codexAdapter } from './codex.js';
 export { opencodeAdapter } from './opencode.js';
 export { antigravityAdapter } from './antigravity.js';
+export { grokAdapter } from './grok.js';
 export { isAgentCallCommand, parseAgentCall } from './agent-call.util.js';
 export declare const BUILTIN_ADAPTERS: Record<string, CliProviderAdapter>;
 export declare function parseStdoutEvent(timestamp: string, message: string, providerId?: string): TaskLogEntry[];

package/dist/provider/cli/index.d.ts

@@ -1,3 +1,3 @@
-export { BUILTIN_ADAPTERS, parseStdoutEvent, claudeAdapter, copilotAdapter, codexAdapter, opencodeAdapter, antigravityAdapter, isAgentCallCommand, parseAgentCall, } from './adapters/index.js';
+export { BUILTIN_ADAPTERS, parseStdoutEvent, claudeAdapter, copilotAdapter, codexAdapter, opencodeAdapter, antigravityAdapter, grokAdapter, isAgentCallCommand, parseAgentCall, } from './adapters/index.js';
 export type { CliProviderAdapter } from './adapter.types.js';
 export { RateLimitError } from './adapter.types.js';

package/dist/provider/cli/meta.d.ts

@@ -1,4 +1,5 @@
 import type { AcpProviderMetaResult } from '../acp/meta.js';
+import type { ModelTier } from '../../config/models.generated.js';
 import type { CliProviderAdapter } from './adapter.types.js';
 export declare function queryOpencodeModels(): Promise<Array<{
     id: string;
@@ -6,6 +7,10 @@ export declare function queryOpencodeModels(): Promise<Array<{
 export declare function cliAdapterMetaToProviderMeta(key: string, adapter: CliProviderAdapter, overrideModels?: Array<{
     id: string;
     name?: string;
+    description?: string;
+    contextWindowTokens?: number;
+    tier?: ModelTier;
+    recommended?: boolean;
 }>): AcpProviderMetaResult | null;
 export declare function queryAllCliProviderMetas(options?: {
     includeOpencodeRuntimeModels?: boolean;

package/dist/provider/cli/protocol-envelope.d.ts

@@ -0,0 +1,2 @@
+export declare function shouldSkipRawStdoutJsonFallback(message: string, providerId?: string): boolean;
+export declare function isProtocolOnlyText(text: string, providerId?: string): boolean;

package/dist/provider/errors.d.ts

@@ -10,6 +10,7 @@ export declare class ProviderError extends Error {
     readonly code: ProviderErrorCode;
     readonly kind?: ProviderErrorKind;
     readonly retryAfterMs?: number;
+    stdout?: string;
     constructor(message: string, providerStr: string, options?: ProviderErrorOptions);
 }
 export declare class IdleTimeoutError extends ProviderError {

package/dist/provider/idle-watchdog.d.ts

@@ -0,0 +1,19 @@
+export interface IdleWatchdogOptions {
+    timeoutMs: number;
+    onIdle: () => void;
+    now?: () => number;
+}
+export declare class IdleWatchdog {
+    private readonly timeoutMs;
+    private readonly onIdleCb;
+    private readonly now;
+    private timer;
+    private lastActivity;
+    private settled;
+    constructor(options: IdleWatchdogOptions);
+    start(): void;
+    refresh(): void;
+    stop(): void;
+    private scheduleCheck;
+    private fireIdle;
+}

package/dist/provider/models.d.ts

@@ -1,9 +1,22 @@
-import { type ModelCatalogEntry, type ProviderCatalogEntry, type ProviderModeEntry, type ProviderModelOverride } from '../config/models.generated.js';
-export type { ModelCatalogEntry, ProviderCatalogEntry, ProviderModeEntry, ProviderModelOverride, } from '../config/models.generated.js';
+import { type ModelCatalogEntry, type ModelTier, type ProviderCatalogEntry, type ProviderDefaultProfile, type ProviderModeEntry, type ProviderModelOverride } from '../config/models.generated.js';
+import type { ModelApiPricing } from '../config/pricing.types.js';
+export type { ModelTier, ModelCatalogEntry, ProviderCatalogEntry, ProviderDefaultProfile, ProviderDefaults, ProviderModeEntry, ProviderOptionSpec, ProviderModelOverride, } from '../config/models.generated.js';
+export type ModelMergeEntry = {
+    id: string;
+    name?: string;
+    description?: string;
+    contextWindowTokens?: number;
+    tier?: ModelTier;
+    recommended?: boolean;
+    apiPricing?: ModelApiPricing;
+};
 export declare function setModelsOverride(providers: Record<string, ProviderCatalogEntry | ModelCatalogEntry[]>): void;
 export declare function clearModelsOverride(): void;
+export declare function setModelsDefaultsOverride(providers: Record<string, ProviderDefaultProfile>): void;
+export declare function clearModelsDefaultsOverride(): void;
 export declare function getProviderModels(provider: string): ModelCatalogEntry[];
 export declare function getProviderCatalog(provider: string): ProviderCatalogEntry;
+export declare function getProviderDefaultProfile(provider: string): ProviderDefaultProfile | undefined;
 export declare function getProviderModes(provider: string): ProviderModeEntry[];
 export declare function getProviderEffort(provider: string, model?: string): string[];
 export declare function getProviderModelOverrides(provider: string): Record<string, ProviderModelOverride>;
@@ -11,13 +24,5 @@ export declare function getClaudeModels(): ModelCatalogEntry[];
 export declare function getCodexModels(): ModelCatalogEntry[];
 export declare function getCopilotModels(): ModelCatalogEntry[];
 export declare function getAntigravityModels(): ModelCatalogEntry[];
-export declare function mergeModels(a: Array<{
-    id: string;
-    name?: string;
-}>, b: Array<{
-    id: string;
-    name?: string;
-}>): Array<{
-    id: string;
-    name?: string;
-}>;
+export declare function mergeModels(a: ModelMergeEntry[], b: ModelMergeEntry[]): ModelMergeEntry[];
+export declare function withApiPricing(models: ModelMergeEntry[]): ModelMergeEntry[];

package/dist/provider/order.d.ts

@@ -1,4 +1,4 @@
-export declare const PROVIDER_ORDER: readonly ["codex", "claude", "opencode", "antigravity", "copilot"];
+export declare const PROVIDER_ORDER: readonly ["codex", "claude", "grok", "opencode", "antigravity", "copilot"];
 export declare function providerRank(id: string): number;
 export declare function compareProviders(a: string, b: string): number;
 export declare function normalizeProviderId(provider?: string): string;

package/dist/provider/parse-usage.d.ts

@@ -3,4 +3,10 @@ export interface ParsedUsage {
     outputTokens: number;
     cachedInputTokens: number;
 }
+export interface ClaudePartialUsage {
+    inputTokens: number;
+    cachedInputTokens: number;
+    model?: string;
+}
+export declare function parseClaudePartialUsage(stdout: string): ClaudePartialUsage | undefined;
 export declare function parseUsage(stdout: string): ParsedUsage | undefined;

package/dist/provider/provider-selection.d.ts

@@ -0,0 +1,8 @@
+import type { CliProviderAdapter } from './cli/adapter.types.js';
+export declare function lookupCliAdapter(providerStr: string): CliProviderAdapter | undefined;
+export type ProviderAvailabilityDeps = {
+    lookupAdapter?: (providerStr: string) => CliProviderAdapter | undefined;
+    env?: NodeJS.ProcessEnv;
+};
+export declare function isProviderAvailable(providerStr: string, deps?: ProviderAvailabilityDeps): boolean;
+export declare function selectAvailableProvider(providers: string | string[], deps?: ProviderAvailabilityDeps): string;

package/dist/provider/redact-technical-message.d.ts

@@ -0,0 +1 @@
+export declare function redactTechnicalMessage(value: unknown): string | undefined;

package/dist/provider/task-error.types.d.ts

@@ -0,0 +1,16 @@
+export type TaskErrorCode = 'USAGE_LIMITED' | 'CONTEXT_WINDOW_EXCEEDED' | 'INPUT_TOO_LARGE' | 'MODEL_NOT_SUPPORTED' | 'MODEL_AT_CAPACITY' | 'AUTH_REQUIRED' | 'CLI_NOT_AVAILABLE' | 'CLI_UPDATE_REQUIRED' | 'AGENT_NOT_FOUND' | 'PERMISSION_OR_TRUST' | 'TIMEOUT_OR_STUCK' | 'NETWORK_OR_PROVIDER_TRANSIENT' | 'PROVIDER_CONFIGURATION' | 'PROCESS_FAILED';
+export interface TaskErrorMeta {
+    resetAt?: string | number;
+    model?: string;
+    cliName?: string;
+    envKey?: string;
+    upstreamType?: string;
+    upstreamCode?: string | number;
+    referenceId?: string;
+    technicalMessage?: string;
+}
+export interface TaskErrorProjection {
+    errorCode: TaskErrorCode | null;
+    errorProvider: string | null;
+    errorMeta?: TaskErrorMeta;
+}

package/dist/publish/constants.d.ts

@@ -0,0 +1,6 @@
+export interface ExcludeRuleDef {
+    label: string;
+    test(basename: string, relPath: string, isDir: boolean): boolean;
+}
+export declare const EXCLUDE_RULES: ExcludeRuleDef[];
+export declare function matchExclude(basename: string, relPath: string, isDir: boolean): string | null;

package/dist/publish/index.d.ts

@@ -0,0 +1,26 @@
+import type { ExcludedEntry } from './scan';
+import type { SecretFinding } from './secrets';
+import type { PublishManifest } from './manifest';
+import { uploadToMarketplace } from './upload';
+import type { PublishUploadOptions, PublishUploadResult } from './upload';
+export interface PublishOptions {
+    version?: string;
+}
+export interface PublishPlan {
+    manifest: PublishManifest;
+    included: string[];
+    excluded: ExcludedEntry[];
+    secretFindings: SecretFinding[];
+}
+export declare function planPublish(dir: string, opts?: PublishOptions): Promise<PublishPlan>;
+export declare function packTemplate(dir: string, opts?: PublishOptions): Promise<{
+    manifest: PublishManifest;
+    tgzPath: string;
+}>;
+export type { PublishManifest, ManifestFile, BuildManifestOptions } from './manifest';
+export type { ExcludedEntry, ScanResult } from './scan';
+export type { SecretFinding } from './secrets';
+export { EXCLUDE_RULES } from './constants';
+export { uploadToMarketplace };
+export type { PublishUploadOptions, PublishUploadResult };
+export { MARKETPLACE_API_PREFIX } from './marketplace-api.constants';

package/dist/publish/index.js

@@ -0,0 +1 @@
+'use strict';var h=require('path'),m=require('fs'),I=require('crypto'),H=require('js-yaml'),N=require('os'),q=require('tar'),zlib=require('zlib');function _interopNamespace(e){if(e&&e.__esModule)return e;var n=Object.create(null);if(e){Object.keys(e).forEach(function(k){if(k!=='default'){var d=Object.getOwnPropertyDescriptor(e,k);Object.defineProperty(n,k,d.get?d:{enumerable:true,get:function(){return e[k]}});}})}n.default=e;return Object.freeze(n)}var h__namespace=/*#__PURE__*/_interopNamespace(h);var m__namespace=/*#__PURE__*/_interopNamespace(m);var I__namespace=/*#__PURE__*/_interopNamespace(I);var H__namespace=/*#__PURE__*/_interopNamespace(H);var N__namespace=/*#__PURE__*/_interopNamespace(N);var q__namespace=/*#__PURE__*/_interopNamespace(q);function W(e){let r=s=>s.replace(/[.+^${}()|[\]\\]/g,"\\$&"),n=e.split("/").map(s=>s==="**"?".*":s.split("*").map(r).join("[^/]*"));return new RegExp(`^${n.join("\\/")}$`)}function b(e,r){try{return W(r).test(e)}catch{return  false}}function T(e,...r){let t=e.split("/");if(t.length<r.length)return  false;let n=t.length-r.length;return r.every((s,i)=>b(t[n+i],s))}function X(e,r){return e.split("/").some(t=>b(t,r))}var $=[{label:".env*",test:e=>b(e,".env*")},{label:".git/",test:(e,r,t)=>t&&e===".git"},{label:"memory/",test:(e,r,t)=>t&&e==="memory"},{label:"*.key",test:e=>b(e,"*.key")},{label:"*.pem",test:e=>b(e,"*.pem")},{label:"auth.json",test:e=>e==="auth.json"},{label:"node_modules/",test:(e,r,t)=>t&&e==="node_modules"},{label:"conversations/",test:(e,r,t)=>t&&e==="conversations"},{label:".crewx/threads/",test:(e,r,t)=>t&&T(r,".crewx","threads")},{label:".crewx/crewx.db",test:(e,r,t)=>!t&&T(r,".crewx","crewx.db")},{label:".crewx/*.log",test:(e,r,t)=>!t&&T(r,".crewx","*.log")},{label:".crewx/publish/",test:(e,r,t)=>t&&T(r,".crewx","publish")},{label:".crewx/",test:(e,r)=>X(r,".crewx")}];function v(e,r,t){for(let n of $)if(n.test(e,r,t))return n.label;return null}function F(e){let r=[],t=[];function n(s,i,a){let p;try{p=m__namespace.readdirSync(s,{withFileTypes:!0});}catch{return}p.sort((o,c)=>o.name.localeCompare(c.name));for(let o of p){let c=i?`${i}/${o.name}`:o.name,l=h__namespace.join(s,o.name);if(o.isSymbolicLink()){let u;try{u=m__namespace.statSync(l);}catch{continue}if(u.isDirectory()){t.push({path:c,rule:a??"symlink-dir"});continue}let x=a??v(o.name,c,false);x?t.push({path:c,rule:x}):r.push(c);continue}if(o.isDirectory()){let u=a??v(o.name,c,true);n(l,c,u);continue}if(o.isFile()){let u=a??v(o.name,c,false);u?t.push({path:c,rule:u}):r.push(c);}}}return n(e,"",null),r.sort(),t.sort((s,i)=>s.path<i.path?-1:s.path>i.path?1:0),{included:r,excluded:t}}var Z=[{rule:"token-prefix",regex:/\b(?:sk-|ghp_|xoxb-)[A-Za-z0-9_-]{10,}/},{rule:"private-key",regex:/-----BEGIN [A-Z ]*PRIVATE KEY-----/},{rule:"aws-access-key",regex:/\bAKIA[0-9A-Z]{16}\b/}];function J(e){return e.includes(0)}function B(e,r){let t=[];for(let n of r){let s=h__namespace.join(e,n),i;try{i=m__namespace.readFileSync(s);}catch{continue}if(J(i))continue;i.toString("utf8").split(/\r\n|\r|\n/).forEach((p,o)=>{for(let{rule:c,regex:l}of Z)l.test(p)&&t.push({path:n,line:o+1,rule:c});});}return t}var z=/^[a-z0-9-]+$/,G=/^\d+\.\d+\.\d+(?:-[0-9A-Za-z.-]+)?(?:\+[0-9A-Za-z.-]+)?$/,Y=/^[A-Za-z_][A-Za-z0-9_]*$/;function Q(e){let r=h__namespace.join(e,"crewx.yaml");if(!m__namespace.existsSync(r))return {};let t;try{t=H__namespace.load(m__namespace.readFileSync(r,"utf8"));}catch{return {}}if(!t||typeof t!="object")return {};let n=t.metadata;if(!n||typeof n!="object")return {};let s=n;return {name:typeof s.name=="string"?s.name:void 0,version:typeof s.version=="string"?s.version:void 0,description:typeof s.description=="string"?s.description:void 0,requiredEnv:s.requiredEnv,crewxMinVersion:typeof s.crewxMinVersion=="string"?s.crewxMinVersion:void 0}}function ee(e){return I__namespace.createHash("sha256").update(new Uint8Array(m__namespace.readFileSync(e))).digest("hex")}function j(e,r,t={}){let n=Q(e),s=n.name??h__namespace.basename(e);if(!z.test(s))throw new Error(`publish: invalid name "${s}" \u2014 must match ${z} (lowercase letters, numbers, hyphen only)`);let i=t.version??n.version;if(!i)throw new Error("publish: version is required \u2014 set crewx.yaml metadata.version or pass opts.version");if(!G.test(i))throw new Error(`publish: invalid version "${i}" \u2014 must be semver (e.g. 1.0.0)`);let a=Array.isArray(n.requiredEnv)?n.requiredEnv:[],p=[];for(let l of a){if(typeof l!="string"||!Y.test(l))throw new Error(`publish: requiredEnv must contain names only (no values), got "${String(l)}"`);p.push(l);}let o=r.map(l=>({path:l,sha256:ee(h__namespace.join(e,l))})).sort((l,u)=>l.path<u.path?-1:l.path>u.path?1:0),c={name:s,version:i,type:"template",description:n.description??"",files:o,requiredEnv:p};return n.crewxMinVersion&&(c.crewxMinVersion=n.crewxMinVersion),c}async function C(e,r){let t=h__namespace.join(e,".crewx","publish");m__namespace.mkdirSync(t,{recursive:true});let n=h__namespace.join(t,`${r.name}-${r.version}.tgz`),s=m__namespace.mkdtempSync(h__namespace.join(N__namespace.tmpdir(),"crewx-publish-"));try{m__namespace.writeFileSync(h__namespace.join(s,"manifest.json"),JSON.stringify(r,null,2));for(let i of r.files){let a=h__namespace.join(s,i.path);m__namespace.mkdirSync(h__namespace.dirname(a),{recursive:!0}),m__namespace.copyFileSync(h__namespace.join(e,i.path),a);}await q__namespace.create({gzip:!0,file:n,cwd:s,portable:!0,noMtime:!0},["manifest.json",...r.files.map(i=>i.path)]);}finally{m__namespace.rmSync(s,{recursive:true,force:true});}return n}var E="/api/v1";var ne=201,se=409,_=401;function ie(){return process.env.WI013_FAKE_UPLOAD==="1"}function ae(e){let r=zlib.gunzipSync(new Uint8Array(e)),t=zlib.gzipSync(new Uint8Array(r),{level:1});if(Buffer.compare(new Uint8Array(t),new Uint8Array(e))===0)throw new Error("publish: [E_MALFORMED] Re-gzipped upload bytes are identical to the original \u2014 tamper is a no-op");return t}function oe(e){return e.replace(/\/+$/,"")}async function P(e){try{return await e.json()}catch{return null}}function V(e,r,t){let n=e;if(!n||n.success!==true||n.data===void 0)throw new Error(`publish: [E_MALFORMED] ${r} response envelope is malformed (expected { success: true, data }) \u2014 HTTP ${t}`);return n.data}async function ce(e){if(!e.baseUrl.trim())throw new Error("publish: [E_ENV_MISSING] Marketplace base URL is required");if(!e.accessToken.trim())throw new Error("publish: [E_AUTH_EXPIRED] A valid bearer token is required");let r=oe(e.baseUrl),t=e.accessPolicy??"private",n=e.manifest.name,s;try{s=await fetch(`${r}${E}/publisher/items`,{method:"POST",headers:{Authorization:`Bearer ${e.accessToken}`,"Content-Type":"application/json"},body:JSON.stringify({slug:n,displayName:n,description:e.manifest.description,type:"template",version:e.manifest.version,accessPolicy:t})});}catch{throw new Error("publish: [E_NETWORK] Submit request failed (network)")}let i;if(s.status===ne)i="created";else if(s.status===se)i="existing";else throw s.status===_?new Error("publish: [E_AUTH_EXPIRED] Authentication is expired or missing \u2014 please log in again (HTTP 401)"):(await P(s),new Error(`publish: [E_HTTP] Submit request failed \u2014 HTTP ${s.status}`));let a="not-needed",p=null;if(i==="existing"){let g;try{g=await fetch(`${r}${E}/publisher/items`,{method:"GET",headers:{Authorization:`Bearer ${e.accessToken}`}});}catch{throw new Error("publish: [E_NETWORK] Publisher items request failed (network)")}let K=await P(g);if(g.status!==200)throw new Error(`publish: [E_HTTP] Publisher items request failed \u2014 HTTP ${g.status}`);let M=V(K,"publisher items",g.status)?.items;if(!Array.isArray(M))throw new Error(`publish: [E_MALFORMED] Publisher items response is malformed (expected data.items[]) \u2014 HTTP ${g.status}`);let A=M.find(f=>!f||typeof f!="object"?false:f.slug===n);if(!A||typeof A.version!="string")throw new Error(`publish: [E_MALFORMED] Publisher items response does not contain slug "${n}" \u2014 HTTP ${g.status}`);if(p=A.version,p!==e.manifest.version){let f;try{f=await fetch(`${r}${E}/publisher/items/${encodeURIComponent(n)}`,{method:"PUT",headers:{Authorization:`Bearer ${e.accessToken}`,"Content-Type":"application/json"},body:JSON.stringify({version:e.manifest.version})});}catch{throw new Error("publish: [E_NETWORK] Version update request failed (network)")}if(!f.ok)throw await P(f),f.status===_?new Error(`publish: [E_AUTH_EXPIRED] Authentication is expired or missing \u2014 please log in again (HTTP ${f.status})`):f.status===403?new Error(`publish: [E_FORBIDDEN] Version update is forbidden; only the item owner can update an existing item (HTTP ${f.status})`):new Error(`publish: [E_HTTP] Version update failed \u2014 HTTP ${f.status}`);a="applied";}}let o=m__namespace.readFileSync(e.tgzPath),c=ie()?ae(o):o,l=new FormData;l.set("archive",new Blob([new Uint8Array(c)],{type:"application/gzip"}),`${n}-${e.manifest.version}.tgz`);let u;try{u=await fetch(`${r}${E}/publisher/items/${encodeURIComponent(n)}/upload`,{method:"POST",headers:{Authorization:`Bearer ${e.accessToken}`},body:l});}catch{throw new Error("publish: [E_NETWORK] Upload request failed (network)")}if(u.status===_)throw new Error("publish: [E_AUTH_EXPIRED] Authentication is expired or missing \u2014 please log in again (HTTP 401)");if(!u.ok)throw await P(u),new Error(`publish: [E_HTTP] Upload request failed \u2014 HTTP ${u.status}`);let x=await P(u),k=V(x,"upload",u.status);return {slug:n,version:e.manifest.version,artifactChecksum:k.artifactChecksum,artifactSizeBytes:k.artifactSizeBytes,submitOutcome:i,versionUpdate:a,serverVersionBefore:p}}async function le(e,r={}){let t=h__namespace.resolve(e),{included:n,excluded:s}=F(t),i=j(t,n,{version:r.version}),a=B(t,n);return {manifest:i,included:n,excluded:s,secretFindings:a}}async function Be(e,r={}){let t=await le(e,r);if(t.secretFindings.length>0){let i=t.secretFindings.map(a=>`${a.path}:${a.line} (${a.rule})`).join(", ");throw new Error(`publish: aborted \u2014 secret findings must be resolved before packing: ${i}`)}let n=h__namespace.resolve(e),s=await C(n,t.manifest);return {manifest:t.manifest,tgzPath:s}}exports.EXCLUDE_RULES=$;exports.MARKETPLACE_API_PREFIX=E;exports.packTemplate=Be;exports.planPublish=le;exports.uploadToMarketplace=ce;

package/dist/publish/manifest.d.ts

@@ -0,0 +1,17 @@
+export interface ManifestFile {
+    path: string;
+    sha256: string;
+}
+export interface PublishManifest {
+    name: string;
+    version: string;
+    type: 'template';
+    description: string;
+    files: ManifestFile[];
+    requiredEnv: string[];
+    crewxMinVersion?: string;
+}
+export interface BuildManifestOptions {
+    version?: string;
+}
+export declare function buildManifest(rootDir: string, includedFiles: string[], opts?: BuildManifestOptions): PublishManifest;

package/dist/publish/marketplace-api.constants.d.ts

@@ -0,0 +1 @@
+export declare const MARKETPLACE_API_PREFIX = "/api/v1";

package/dist/publish/pack.d.ts

@@ -0,0 +1,2 @@
+import type { PublishManifest } from './manifest';
+export declare function createArchive(rootDir: string, manifest: PublishManifest): Promise<string>;

package/dist/publish/scan.d.ts

@@ -0,0 +1,9 @@
+export interface ExcludedEntry {
+    path: string;
+    rule: string;
+}
+export interface ScanResult {
+    included: string[];
+    excluded: ExcludedEntry[];
+}
+export declare function scanWorkspace(rootDir: string): ScanResult;

package/dist/publish/secrets.d.ts

@@ -0,0 +1,6 @@
+export interface SecretFinding {
+    path: string;
+    line: number;
+    rule: string;
+}
+export declare function scanForSecrets(rootDir: string, includedFiles: string[]): SecretFinding[];

package/dist/publish/upload.d.ts

@@ -0,0 +1,18 @@
+import type { PublishManifest } from './manifest';
+export interface PublishUploadOptions {
+    tgzPath: string;
+    manifest: PublishManifest;
+    baseUrl: string;
+    accessToken: string;
+    accessPolicy?: 'private';
+}
+export interface PublishUploadResult {
+    slug: string;
+    version: string;
+    artifactChecksum: string;
+    artifactSizeBytes: number;
+    submitOutcome: 'created' | 'existing';
+    versionUpdate: 'not-needed' | 'applied';
+    serverVersionBefore: string | null;
+}
+export declare function uploadToMarketplace(opts: PublishUploadOptions): Promise<PublishUploadResult>;

package/dist/remote/execution-profile.d.ts

@@ -0,0 +1,9 @@
+import type { AgentExecutionProfile } from './types.js';
+export declare function resolveAgentExecutionProfiles(input: {
+    location: string;
+    targetAgentIds: string[];
+}): Map<string, AgentExecutionProfile>;
+export declare function resolveAgentExecutionProfile(input: {
+    location: string;
+    targetAgentId: string;
+}): AgentExecutionProfile;

package/dist/remote/index.d.ts

@@ -5,3 +5,4 @@ export { RemoteAgentManager } from './remote-agent-manager.js';
 export type { RemoteAgentManagerOptions } from './remote-agent-manager.js';
 export { RemoteProviderRuntime, createRemoteProviderFactory, resolveFileRemoteAgent } from './remote-provider.js';
 export type { ProviderFactoryFn, FileRemoteResolution, FileRemoteResolver } from './remote-provider.js';
+export { resolveAgentExecutionProfile, resolveAgentExecutionProfiles, } from './execution-profile.js';

package/dist/remote/types.d.ts

@@ -44,6 +44,34 @@ export interface RemoteProviderConfig {
     apiKey?: string;
     headers?: Record<string, string>;
 }
+export type AgentExecutionProfileStatus = 'resolved' | 'pending' | 'unavailable';
+export type AgentExecutionProfileErrorCode = 'TARGET_NOT_FOUND' | 'TARGET_AGENT_NOT_FOUND' | 'TARGET_NO_PROVIDER' | 'CHAINED_REMOTE' | 'TARGET_PARSE_FAILED' | 'TRANSPORT_ERROR';
+export interface AgentExecutionProfileSlot {
+    provider?: string;
+    model?: string;
+    effort?: string;
+    overdrive?: {
+        provider: string;
+        model: string;
+        mode?: string;
+        effort?: string;
+    };
+}
+export interface AgentExecutionProfile {
+    status: AgentExecutionProfileStatus;
+    location?: string;
+    agentId?: string;
+    provider?: string;
+    model?: string;
+    options?: {
+        query?: AgentExecutionProfileSlot;
+        execute?: AgentExecutionProfileSlot;
+    };
+    error?: {
+        code: AgentExecutionProfileErrorCode;
+        message: string;
+    };
+}
 export interface RemoteAgentQueryRequest {
     agentId: string;
     query: string;

package/dist/repository/agent-suggestion.repository.d.ts

@@ -0,0 +1,34 @@
+import { BaseSqliteRepository } from './base-sqlite-repository.js';
+import { agent_suggestions } from '../schema/index.js';
+export type AgentSuggestionRow = typeof agent_suggestions.$inferSelect;
+export type NewAgentSuggestion = typeof agent_suggestions.$inferInsert;
+export type SuggestionType = 'H1' | 'H3';
+export type SuggestionStatus = 'pending' | 'applied' | 'dismissed';
+export interface CreateAgentSuggestionInput {
+    workspaceId: string;
+    agentId: string;
+    taskId?: string | null;
+    type: SuggestionType;
+    status?: SuggestionStatus;
+    payload: string;
+    appliedCommitSha?: string | null;
+}
+export declare const DEFAULT_LIST_LIMIT = 50;
+export declare class AgentSuggestionRepository extends BaseSqliteRepository {
+    private readonly dbPath?;
+    constructor(opts?: {
+        dbPath?: string;
+        dbRoot?: string;
+    });
+    resolveDbPath(): string;
+    private openHandle;
+    create(rows: CreateAgentSuggestionInput[]): {
+        ids: string[];
+    };
+    findLatestSet(workspaceId: string, agentId: string): AgentSuggestionRow[];
+    findSetByTaskId(workspaceId: string, agentId: string, taskId: string): AgentSuggestionRow[];
+    findById(workspaceId: string, agentId: string, suggestionId: string): AgentSuggestionRow | null;
+    updateStatus(id: string, status: SuggestionStatus, appliedCommitSha?: string | null): boolean;
+    listByAgent(workspaceId: string, agentId: string, limit?: number): AgentSuggestionRow[];
+    findDismissed(workspaceId: string, agentId: string, limit?: number): AgentSuggestionRow[];
+}

package/dist/repository/common-code.repository.d.ts

@@ -0,0 +1,45 @@
+import { BaseSqliteRepository } from './base-sqlite-repository.js';
+import { RepositoryError } from './errors.js';
+import type { CommonCode, CommonCodeColor, CommonCodeGroup } from '../schema/index.js';
+export { COMMON_CODE_COLORS, COMMON_CODE_GROUPS } from '../schema/common-codes.js';
+export type { CommonCodeColor, CommonCodeGroup } from '../schema/common-codes.js';
+export type CommonCodeErrorReason = 'COMMON_CODE_GROUP_INVALID' | 'COMMON_CODE_COLOR_INVALID' | 'COMMON_CODE_NAME_INVALID' | 'COMMON_CODE_CODE_INVALID' | 'COMMON_CODE_WORKSPACE_INVALID' | 'COMMON_CODE_NAME_CONFLICT' | 'COMMON_CODE_NOT_FOUND' | 'COMMON_CODE_SCOPE_FORBIDDEN' | 'COMMON_CODE_BUILTIN_ARCHIVE_FORBIDDEN' | 'COMMON_CODE_ARCHIVE_INVALID' | 'COMMON_CODE_UPDATE_EMPTY' | 'COMMON_CODE_REORDER_INVALID';
+export declare class CommonCodeRepositoryError extends RepositoryError {
+    readonly reason: CommonCodeErrorReason;
+    constructor(reason: CommonCodeErrorReason, code?: 'VALIDATION' | 'NOT_FOUND' | 'CONFLICT', message?: string, cause?: unknown);
+}
+export interface CreateThreadStateInput {
+    workspaceId: string;
+    name: string;
+    color: CommonCodeColor;
+}
+export interface UpdateCommonCodeDisplayInput {
+    group: CommonCodeGroup;
+    code: string;
+    workspaceId: string;
+    name?: string | null;
+    color?: CommonCodeColor;
+}
+export interface ReorderCommonCodesInput {
+    group: string;
+    workspaceId: string;
+    codes: string[];
+}
+export declare function generateCommonCodeId(): string;
+export declare class CommonCodeRepository extends BaseSqliteRepository {
+    private readonly dbPath?;
+    constructor(opts?: {
+        dbPath?: string;
+        dbRoot?: string;
+    });
+    resolveDbPath(): string;
+    private openHandle;
+    listSelectable(group: string, workspaceId: string): CommonCode[];
+    listForHistory(group: string, workspaceId: string): CommonCode[];
+    reorder(input: ReorderCommonCodesInput): CommonCode[];
+    resolve(group: string, code: string): CommonCode | null;
+    createThreadState(input: CreateThreadStateInput): CommonCode;
+    updateDisplay(input: UpdateCommonCodeDisplayInput): CommonCode;
+    archive(group: string, code: string, workspaceId: string, archived?: boolean): CommonCode;
+    private assertOwnership;
+}

package/dist/repository/db.d.ts

@@ -6,4 +6,12 @@ export interface DrizzleHandle {
     runRaw(sqlStr: string, params?: unknown[]): void;
     close(): void;
 }
+export declare const CREWX_JOURNAL_SIZE_LIMIT_BYTES: number;
+export type ReclaimJournalMode = 'PASSIVE' | 'TRUNCATE';
+export interface ReclaimJournalResult {
+    busy: boolean;
+    walBytesBefore: number;
+    walBytesAfter: number;
+}
 export declare function openDrizzleDb(dbPath: string): DrizzleHandle;
+export declare function reclaimTemporaryJournal(dbPath: string, mode?: ReclaimJournalMode): ReclaimJournalResult;