@crewx/sdk 0.9.0-rc.7 → 0.9.0-rc.71

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>;
@@ -18,6 +19,9 @@ export declare class AcpConnection {
     private stderrBuffer;
     private collectedStderr;
     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;
@@ -37,6 +39,11 @@ export declare class ClientToolCallRequiredError extends Error {
     constructor(toolCall: ClientToolCall, continuationState: ContinuationState);
 }
 export type ProviderFactory = (id: string, providerStr: string) => ProviderRuntime;
+export type AdditionalArgsProvider = (ctx: {
+    providerStr: string;
+    providerId: string;
+    mode?: string;
+}) => string[];
 export declare function registerProviderFactory(namespace: string, factory: ProviderFactory): void;
 export interface ProviderUsage {
     inputTokens: number;
@@ -48,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;
@@ -62,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;
@@ -76,4 +87,8 @@ export interface ProviderRuntime {
     }>, options?: ProviderQueryOptions): Promise<string>;
     dispose?(): Promise<void>;
 }
-export declare function createProvider(providerStr: string): ProviderRuntime;
+export declare function createProvider(providerStr: string, additionalArgsProvider?: AdditionalArgsProvider): ProviderRuntime;
+export declare function mergeAdditionalArgs(options: ProviderQueryOptions | undefined, provider: AdditionalArgsProvider | undefined, ctx: {
+    providerStr: string;
+    providerId: string;
+}): ProviderQueryOptions;

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;

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

@@ -3,5 +3,13 @@ export declare function decodeModelEffort(model?: string): {
     effort?: string;
 };
 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/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/auth-boundary.d.ts

@@ -0,0 +1,22 @@
+export type AccountAuthBoundaryErrorCode = 'ACCOUNT_USER_PAIR_MISSING' | 'ACCOUNT_USER_ISSUER_MISSING' | 'ACCOUNT_USER_ANON_KEY_MISSING' | 'ACCOUNT_ACCESS_TOKEN_INVALID' | 'ACCOUNT_TOKEN_ISSUER_MISMATCH' | 'ACCOUNT_TOKEN_SUB_MISMATCH' | 'ACCOUNT_AUTH_JSON_ISSUER_MISMATCH' | 'ACCOUNT_AUTH_JSON_SUB_MISMATCH';
+export declare class AccountAuthBoundaryError extends Error {
+    readonly code: AccountAuthBoundaryErrorCode;
+    constructor(code: AccountAuthBoundaryErrorCode, message: string);
+}
+export interface UserAccountConfig {
+    issuer: string;
+    anonKey: string;
+}
+export declare function resolveUserAccountConfig(env?: Readonly<Record<string, string | undefined>>): UserAccountConfig;
+export interface AccessTokenIdentity {
+    issuer: string;
+    sub: string;
+}
+export declare function decodeAccessTokenIdentity(accessToken: string): AccessTokenIdentity;
+export declare function assertUserRealmAccessToken(accessToken: string, config: Pick<UserAccountConfig, 'issuer'>, expectedSub?: string): AccessTokenIdentity;
+export interface AuthJsonIdentity {
+    issuer: string;
+    sub: string;
+    access_token: string;
+}
+export declare function assertAuthJsonUserRealm(auth: AuthJsonIdentity, config: Pick<UserAccountConfig, 'issuer'>): AccessTokenIdentity;

package/dist/publish/auth-json.d.ts

@@ -0,0 +1,11 @@
+export interface AuthJson {
+    version: 1;
+    issuer: string;
+    sub: string;
+    email: string;
+    access_token: string;
+    refresh_token: string;
+    expires_at: number;
+    updated_at: string;
+}
+export declare function readAuthJson(): AuthJson;

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,30 @@
+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 { readAuthJson } from './auth-json';
+export type { AuthJson } from './auth-json';
+export { AccountAuthBoundaryError, assertAuthJsonUserRealm, assertUserRealmAccessToken, decodeAccessTokenIdentity, resolveUserAccountConfig, } from './auth-boundary';
+export type { AccessTokenIdentity, AccountAuthBoundaryErrorCode, AuthJsonIdentity, UserAccountConfig, } from './auth-boundary';
+export { MARKETPLACE_API_PREFIX } from './marketplace-api.constants';

package/dist/publish/index.js

@@ -0,0 +1 @@
+'use strict';var y=require('path'),h=require('fs'),X=require('crypto'),W=require('js-yaml'),I=require('os'),Y=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 y__namespace=/*#__PURE__*/_interopNamespace(y);var h__namespace=/*#__PURE__*/_interopNamespace(h);var X__namespace=/*#__PURE__*/_interopNamespace(X);var W__namespace=/*#__PURE__*/_interopNamespace(W);var I__namespace=/*#__PURE__*/_interopNamespace(I);var Y__namespace=/*#__PURE__*/_interopNamespace(Y);function ae(e){let t=n=>n.replace(/[.+^${}()|[\]\\]/g,"\\$&"),s=e.split("/").map(n=>n==="**"?".*":n.split("*").map(t).join("[^/]*"));return new RegExp(`^${s.join("\\/")}$`)}function w(e,t){try{return ae(t).test(e)}catch{return  false}}function C(e,...t){let r=e.split("/");if(r.length<t.length)return  false;let s=r.length-t.length;return t.every((n,i)=>w(r[s+i],n))}function ce(e,t){return e.split("/").some(r=>w(r,t))}var D=[{label:".env*",test:e=>w(e,".env*")},{label:".git/",test:(e,t,r)=>r&&e===".git"},{label:"memory/",test:(e,t,r)=>r&&e==="memory"},{label:"*.key",test:e=>w(e,"*.key")},{label:"*.pem",test:e=>w(e,"*.pem")},{label:"auth.json",test:e=>e==="auth.json"},{label:"node_modules/",test:(e,t,r)=>r&&e==="node_modules"},{label:"conversations/",test:(e,t,r)=>r&&e==="conversations"},{label:".crewx/threads/",test:(e,t,r)=>r&&C(t,".crewx","threads")},{label:".crewx/crewx.db",test:(e,t,r)=>!r&&C(t,".crewx","crewx.db")},{label:".crewx/*.log",test:(e,t,r)=>!r&&C(t,".crewx","*.log")},{label:".crewx/publish/",test:(e,t,r)=>r&&C(t,".crewx","publish")},{label:".crewx/",test:(e,t)=>ce(t,".crewx")}];function v(e,t,r){for(let s of D)if(s.test(e,t,r))return s.label;return null}function J(e){let t=[],r=[];function s(n,i,a){let d;try{d=h__namespace.readdirSync(n,{withFileTypes:!0});}catch{return}d.sort((c,u)=>c.name.localeCompare(u.name));for(let c of d){let u=i?`${i}/${c.name}`:c.name,l=y__namespace.join(n,c.name);if(c.isSymbolicLink()){let p;try{p=h__namespace.statSync(l);}catch{continue}if(p.isDirectory()){r.push({path:u,rule:a??"symlink-dir"});continue}let U=a??v(c.name,u,false);U?r.push({path:u,rule:U}):t.push(u);continue}if(c.isDirectory()){let p=a??v(c.name,u,true);s(l,u,p);continue}if(c.isFile()){let p=a??v(c.name,u,false);p?r.push({path:u,rule:p}):t.push(u);}}}return s(e,"",null),t.sort(),r.sort((n,i)=>n.path<i.path?-1:n.path>i.path?1:0),{included:t,excluded:r}}var ue=[{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 le(e){return e.includes(0)}function L(e,t){let r=[];for(let s of t){let n=y__namespace.join(e,s),i;try{i=h__namespace.readFileSync(n);}catch{continue}if(le(i))continue;i.toString("utf8").split(/\r\n|\r|\n/).forEach((d,c)=>{for(let{rule:u,regex:l}of ue)l.test(d)&&r.push({path:s,line:c+1,rule:u});});}return r}var V=/^[a-z0-9-]+$/,pe=/^\d+\.\d+\.\d+(?:-[0-9A-Za-z.-]+)?(?:\+[0-9A-Za-z.-]+)?$/,fe=/^[A-Za-z_][A-Za-z0-9_]*$/;function de(e){let t=y__namespace.join(e,"crewx.yaml");if(!h__namespace.existsSync(t))return {};let r;try{r=W__namespace.load(h__namespace.readFileSync(t,"utf8"));}catch{return {}}if(!r||typeof r!="object")return {};let s=r.metadata;if(!s||typeof s!="object")return {};let n=s;return {name:typeof n.name=="string"?n.name:void 0,version:typeof n.version=="string"?n.version:void 0,description:typeof n.description=="string"?n.description:void 0,requiredEnv:n.requiredEnv,crewxMinVersion:typeof n.crewxMinVersion=="string"?n.crewxMinVersion:void 0}}function me(e){return X__namespace.createHash("sha256").update(new Uint8Array(h__namespace.readFileSync(e))).digest("hex")}function G(e,t,r={}){let s=de(e),n=s.name??y__namespace.basename(e);if(!V.test(n))throw new Error(`publish: invalid name "${n}" \u2014 must match ${V} (lowercase letters, numbers, hyphen only)`);let i=r.version??s.version;if(!i)throw new Error("publish: version is required \u2014 set crewx.yaml metadata.version or pass opts.version");if(!pe.test(i))throw new Error(`publish: invalid version "${i}" \u2014 must be semver (e.g. 1.0.0)`);let a=Array.isArray(s.requiredEnv)?s.requiredEnv:[],d=[];for(let l of a){if(typeof l!="string"||!fe.test(l))throw new Error(`publish: requiredEnv must contain names only (no values), got "${String(l)}"`);d.push(l);}let c=t.map(l=>({path:l,sha256:me(y__namespace.join(e,l))})).sort((l,p)=>l.path<p.path?-1:l.path>p.path?1:0),u={name:n,version:i,type:"template",description:s.description??"",files:c,requiredEnv:d};return s.crewxMinVersion&&(u.crewxMinVersion=s.crewxMinVersion),u}async function Q(e,t){let r=y__namespace.join(e,".crewx","publish");h__namespace.mkdirSync(r,{recursive:true});let s=y__namespace.join(r,`${t.name}-${t.version}.tgz`),n=h__namespace.mkdtempSync(y__namespace.join(I__namespace.tmpdir(),"crewx-publish-"));try{h__namespace.writeFileSync(y__namespace.join(n,"manifest.json"),JSON.stringify(t,null,2));for(let i of t.files){let a=y__namespace.join(n,i.path);h__namespace.mkdirSync(y__namespace.dirname(a),{recursive:!0}),h__namespace.copyFileSync(y__namespace.join(e,i.path),a);}await Y__namespace.create({gzip:!0,file:s,cwd:n,portable:!0,noMtime:!0},["manifest.json",...t.files.map(i=>i.path)]);}finally{h__namespace.rmSync(n,{recursive:true,force:true});}return s}var A="/api/v1";var ye=201,Ee=409,$=401;function be(){return process.env.WI013_FAKE_UPLOAD==="1"}function we(e){let t=zlib.gunzipSync(new Uint8Array(e)),r=zlib.gzipSync(new Uint8Array(t),{level:1});if(Buffer.compare(new Uint8Array(r),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 r}function Ae(e){return e.replace(/\/+$/,"")}async function P(e){try{return await e.json()}catch{return null}}function E(e){let t=e?.message;return typeof t=="string"?t:void 0}function ee(e,t,r){let s=e;if(!s||s.success!==true||s.data===void 0)throw new Error(`publish: [E_MALFORMED] ${t} response envelope is malformed (expected { success: true, data }) \u2014 HTTP ${r}`);return s.data}async function _e(e){let t=Ae(e.baseUrl),r=e.accessPolicy??"private",s=e.manifest.name,n;try{n=await fetch(`${t}${A}/publisher/items`,{method:"POST",headers:{Authorization:`Bearer ${e.accessToken}`,"Content-Type":"application/json"},body:JSON.stringify({slug:s,displayName:s,description:e.manifest.description,type:"template",version:e.manifest.version,accessPolicy:r})});}catch(o){throw new Error(`publish: [E_NETWORK] Submit request failed (network) \u2014 ${o instanceof Error?o.message:String(o)}`)}let i;if(n.status===ye)i="created";else if(n.status===Ee)i="existing";else {if(n.status===$)throw new Error("publish: [E_AUTH_EXPIRED] Authentication is expired or missing \u2014 please log in again (HTTP 401)");{let o=await P(n);throw new Error(`publish: [E_HTTP] Submit request failed \u2014 HTTP ${n.status}${E(o)?` ${E(o)}`:""}`)}}let a="not-needed",d=null;if(i==="existing"){let o;try{o=await fetch(`${t}${A}/publisher/items`,{method:"GET",headers:{Authorization:`Bearer ${e.accessToken}`}});}catch(f){throw new Error(`publish: [E_NETWORK] Publisher items request failed (network) \u2014 ${f instanceof Error?f.message:String(f)}`)}let M=await P(o);if(o.status!==200)throw new Error(`publish: [E_HTTP] Publisher items request failed \u2014 HTTP ${o.status}${E(M)?` ${E(M)}`:""}`);let B=ee(M,"publisher items",o.status)?.items;if(!Array.isArray(B))throw new Error(`publish: [E_MALFORMED] Publisher items response is malformed (expected data.items[]) \u2014 HTTP ${o.status}`);let O=B.find(f=>!f||typeof f!="object"?false:f.slug===s);if(!O||typeof O.version!="string")throw new Error(`publish: [E_MALFORMED] Publisher items response does not contain slug "${s}" \u2014 HTTP ${o.status}`);if(d=O.version,d!==e.manifest.version){let f;try{f=await fetch(`${t}${A}/publisher/items/${encodeURIComponent(s)}`,{method:"PUT",headers:{Authorization:`Bearer ${e.accessToken}`,"Content-Type":"application/json"},body:JSON.stringify({version:e.manifest.version})});}catch(T){throw new Error(`publish: [E_NETWORK] Version update request failed (network) \u2014 ${T instanceof Error?T.message:String(T)}`)}if(!f.ok){let T=await P(f),b=E(T);throw f.status===$?new Error(`publish: [E_AUTH_EXPIRED] Authentication is expired or missing \u2014 please log in again (HTTP ${f.status})${b?` ${b}`:""}`):f.status===403?new Error(`publish: [E_FORBIDDEN] Version update is forbidden; only the item owner can update an existing item (HTTP ${f.status})${b?` ${b}`:""}`):new Error(`publish: [E_HTTP] Version update failed \u2014 HTTP ${f.status}${b?` ${b}`:""}`)}a="applied";}}let c=h__namespace.readFileSync(e.tgzPath),u=be()?we(c):c,l=new FormData;l.set("archive",new Blob([new Uint8Array(u)],{type:"application/gzip"}),`${s}-${e.manifest.version}.tgz`);let p;try{p=await fetch(`${t}${A}/publisher/items/${encodeURIComponent(s)}/upload`,{method:"POST",headers:{Authorization:`Bearer ${e.accessToken}`},body:l});}catch(o){throw new Error(`publish: [E_NETWORK] Upload request failed (network) \u2014 ${o instanceof Error?o.message:String(o)}`)}if(p.status===$)throw new Error("publish: [E_AUTH_EXPIRED] Authentication is expired or missing \u2014 please log in again (HTTP 401)");if(!p.ok){let o=await P(p);throw new Error(`publish: [E_HTTP] Upload request failed \u2014 HTTP ${p.status}${E(o)?` ${E(o)}`:""}`)}let U=await P(p),j=ee(U,"upload",p.status);return {slug:s,version:e.manifest.version,artifactChecksum:j.artifactChecksum,artifactSizeBytes:j.artifactSizeBytes,submitOutcome:i,versionUpdate:a,serverVersionBefore:d}}function ne(){if(process.env.CREWX_HOME)try{return h__namespace.realpathSync(process.env.CREWX_HOME)}catch{return y__namespace.join(I__namespace.homedir(),".crewx")}return process.platform!=="win32"&&process.env.XDG_CONFIG_HOME?y__namespace.join(process.env.XDG_CONFIG_HOME,"crewx"):y__namespace.join(I__namespace.homedir(),".crewx")}var g=class extends Error{code;constructor(t,r){super(r),this.name="AccountAuthBoundaryError",this.code=t;}};function N(e=process.env){let t=e.CREWX_ACCOUNT_ISSUER?.trim(),r=e.CREWX_ACCOUNT_ANON_KEY?.trim();if(!t&&!r)throw new g("ACCOUNT_USER_PAIR_MISSING","CrewX user-realm issuer and anon/publishable key pair are not configured");if(!t)throw new g("ACCOUNT_USER_ISSUER_MISSING","CrewX user-realm issuer is not configured");if(!r)throw new g("ACCOUNT_USER_ANON_KEY_MISSING","CrewX user-realm anon/publishable key is not configured");return {issuer:t,anonKey:r}}function _(){throw new g("ACCOUNT_ACCESS_TOKEN_INVALID","Account access token could not be verified")}function se(e){try{return JSON.parse(Buffer.from(e,"base64url").toString("utf8"))}catch{return _()}}function ie(e){if(typeof e!="string")return _();let t=e.split(".");if(t.length!==3||t.some(i=>i.length===0))return _();let r=se(t[0]),s=se(t[1]);if(!r||typeof r!="object"||!s||typeof s!="object")return _();let n=s;return typeof n.iss!="string"||n.iss.length===0||typeof n.sub!="string"||n.sub.length===0?_():{issuer:n.iss,sub:n.sub}}function oe(e,t,r){let s=ie(e);if(s.issuer!==t.issuer)throw new g("ACCOUNT_TOKEN_ISSUER_MISMATCH","Account access token does not match the configured user realm");if(r!==void 0&&s.sub!==r)throw new g("ACCOUNT_TOKEN_SUB_MISMATCH","Account access token subject does not match the expected identity");return s}function H(e,t){if(e.issuer!==t.issuer)throw new g("ACCOUNT_AUTH_JSON_ISSUER_MISMATCH","auth.json does not match the configured user realm");let r=oe(e.access_token,t);if(r.sub!==e.sub)throw new g("ACCOUNT_AUTH_JSON_SUB_MISMATCH","auth.json subject does not match the access token identity");return r}function Pe(e){if(!e||typeof e!="object")return  false;let t=e;return t.version===1&&typeof t.sub=="string"&&typeof t.email=="string"&&typeof t.access_token=="string"&&typeof t.refresh_token=="string"&&typeof t.expires_at=="number"&&typeof t.issuer=="string"&&typeof t.updated_at=="string"}function Ue(){let e=y.join(ne(),"auth.json");if(!h.existsSync(e))throw new Error(`Login required \u2014 ${e} was not found (please log in first)`);let t;try{t=h.readFileSync(e,"utf8");}catch(n){throw new Error(`Could not read auth.json (${e}): ${n instanceof Error?n.message:String(n)}`)}let r;try{r=JSON.parse(t);}catch(n){throw new Error(`Failed to parse auth.json (${e}): ${n instanceof Error?n.message:String(n)}`)}if(!Pe(r))throw new Error(`auth.json is malformed (${e}) \u2014 please log in again`);let s=N();return H(r,s),r}async function Ce(e,t={}){let r=y__namespace.resolve(e),{included:s,excluded:n}=J(r),i=G(r,s,{version:t.version}),a=L(r,s);return {manifest:i,included:s,excluded:n,secretFindings:a}}async function pt(e,t={}){let r=await Ce(e,t);if(r.secretFindings.length>0){let i=r.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 s=y__namespace.resolve(e),n=await Q(s,r.manifest);return {manifest:r.manifest,tgzPath:n}}exports.AccountAuthBoundaryError=g;exports.EXCLUDE_RULES=D;exports.MARKETPLACE_API_PREFIX=A;exports.assertAuthJsonUserRealm=H;exports.assertUserRealmAccessToken=oe;exports.decodeAccessTokenIdentity=ie;exports.packTemplate=pt;exports.planPublish=Ce;exports.readAuthJson=Ue;exports.resolveUserAccountConfig=N;exports.uploadToMarketplace=_e;

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/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/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;

package/dist/repository/index.d.ts

@@ -3,15 +3,22 @@ export { RepositoryError } from './errors.js';
 export type { RepositoryErrorCode } from './errors.js';
 export { WorkspaceRepository } from './workspace.repository.js';
 export type { ProjectRow, ThreadRow as WorkspaceThreadRow, ThreadWithAgentRow } from './workspace.repository.js';
-export { openDrizzleDb } from './db.js';
-export type { DrizzleDb, DrizzleHandle } from './db.js';
+export { DEFAULT_PROJECT_STAGE_KEYS, DEFAULT_PROJECT_STAGES, ProjectRepository, } from './project.repository.js';
+export type { AcceptProjectInput, AppendProjectEventInput, CreateProjectInput, CriterionVerifyStatus, ListProjectEventsOptions, ListProjectsOptions, ProjectActorInput, ProjectActorType, ProjectDetail, ProjectEvidence, ProjectEvidenceKind, ProjectEventType, ProjectScene, ProjectStage, SetCriterionEvidenceInput, SetCriterionVerifyInput, } from './project.repository.js';
+export { CREWX_JOURNAL_SIZE_LIMIT_BYTES, openDrizzleDb, reclaimTemporaryJournal } from './db.js';
+export type { DrizzleDb, DrizzleHandle, ReclaimJournalMode, ReclaimJournalResult } from './db.js';
 export { runMigrations, runMigrationsOnce } from './migrate.js';
 export { pushSchema } from './push.js';
 export type { PushResult } from './push.js';
 export type { Workspace, NewWorkspace } from '../schema/index.js';
 export { tasks } from '../schema/index.js';
 export { TaskRepository } from './task.repository.js';
-export type { TaskRow, NewTask, AgentUsageRow, TrendRow, ProviderUsageRow } from './task.repository.js';
+export type { TaskRow, TaskListRow, NewTask, AgentUsageRow, TrendRow, ProviderUsageRow, ModelUsageRow, ReportTaskRow, DelegationEdge, DelegationMatrixResult, WorkflowCardRow, WorkflowParentTaskRow, } from './task.repository.js';
+export { TaskLogRepository } from './task-log.repository.js';
+export type { TaskLogEntry, RawTaskLogEntry, TaskLogRawEntry, TaskLogStorage, TaskLogState, TaskLogReadResult, TaskLogRepositoryContract, } from './task-log.repository.js';
+export { runTaskLogMigration, resolveTaskLogMigrationDbPath, taskLogBackupName, tryCheckpointTaskLogWal, hasSufficientTaskLogMigrationFreeSpace, } from './task-log-migration.js';
+export { TASK_LOG_MIGRATION_EVENT_ROW_BYTES, TASK_LOG_MIGRATION_MIN_FREE_SPACE_BYTES, TASK_LOG_MIGRATION_TERMINAL_STATUSES, } from './task-log-migration.js';
+export type { TaskLogMigrationFailure, TaskLogMigrationFailureKind, TaskLogMigrationMode, TaskLogMigrationOptions, TaskLogMigrationReport, TaskLogWalCheckpointConnection, TaskLogVerificationIssue, TaskLogVerificationIssueKind, TaskLogVerificationReport, } from './task-log-migration.js';
 export { ThreadRepository } from './thread.repository.js';
 export type { ThreadRow, NewThread } from './thread.repository.js';
 export { SpanRepository } from './span.repository.js';
@@ -24,3 +31,9 @@ export { RequestLogRepository } from './request-log.repository.js';
 export type { RequestLogRow, NewRequestLog, RequestLogEntry } from './request-log.repository.js';
 export { UsageLimitSnapshotRepository, calcBucketStart } from './usage-limit-snapshot.repository.js';
 export type { UsageLimitSnapshotRow, NewUsageLimitSnapshot, UpsertSnapshotInput, LimitTrendPoint, LimitTrendProvider, } from './usage-limit-snapshot.repository.js';
+export { UsageReportRepository } from './usage-report.repository.js';
+export type { UsageReportRow, NewUsageReport, PublishReportInput } from './usage-report.repository.js';
+export { NotificationRepository, DEFAULT_NOTIFICATION_CAP, DEFAULT_LIST_LIMIT as DEFAULT_NOTIFICATION_LIST_LIMIT, } from './notification.repository.js';
+export type { NotificationRow, NewNotification, NotificationReadRow, NotificationLevel, NotificationSource, CreateNotificationInput, NotificationListItem, ListNotificationsParams, UserScope as NotificationUserScope, MarkReadParams as NotificationMarkReadParams, } from './notification.repository.js';
+export { AgentSuggestionRepository, DEFAULT_LIST_LIMIT as DEFAULT_AGENT_SUGGESTION_LIST_LIMIT, } from './agent-suggestion.repository.js';
+export type { AgentSuggestionRow, NewAgentSuggestion, SuggestionType, SuggestionStatus, CreateAgentSuggestionInput, } from './agent-suggestion.repository.js';