@crewx/sdk 0.9.0-rc.5 → 0.9.0-rc.50

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

@@ -1,3 +1,4 @@
+import type { ProviderDefaultProfile } from '../models.js';
 import type { InitializeResponse, NewSessionResponse } from './types.js';
 export interface AcpProviderMetaResult {
     id: string;
@@ -12,6 +13,11 @@ export interface AcpProviderMetaResult {
         id: string;
         name?: string;
     }>;
+    modelOverrides?: Record<string, {
+        effort?: string[];
+        defaultEffort?: string;
+    }>;
+    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;
@@ -62,6 +69,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 +84,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

@@ -13,6 +13,7 @@ export interface CliProviderAdapter {
             query?: number;
             execute?: number;
         };
+        defaultIdleMs?: number;
         capabilities?: {
             resume?: boolean;
             image?: boolean;

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

@@ -3,5 +3,7 @@ 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[];

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

@@ -1,4 +1,12 @@
 import type { AcpProviderMetaResult } from '../acp/meta.js';
 import type { CliProviderAdapter } from './adapter.types.js';
-export declare function cliAdapterMetaToProviderMeta(key: string, adapter: CliProviderAdapter): AcpProviderMetaResult | null;
-export declare function queryAllCliProviderMetas(): AcpProviderMetaResult[];
+export declare function queryOpencodeModels(): Promise<Array<{
+    id: string;
+}>>;
+export declare function cliAdapterMetaToProviderMeta(key: string, adapter: CliProviderAdapter, overrideModels?: Array<{
+    id: string;
+    name?: string;
+}>): AcpProviderMetaResult | null;
+export declare function queryAllCliProviderMetas(options?: {
+    includeOpencodeRuntimeModels?: boolean;
+}): Promise<AcpProviderMetaResult[]>;

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

@@ -0,0 +1,26 @@
+import { type ModelCatalogEntry, type ProviderCatalogEntry, type ProviderDefaultProfile, type ProviderModeEntry, type ProviderModelOverride } from '../config/models.generated.js';
+export type { ModelCatalogEntry, ProviderCatalogEntry, ProviderDefaultProfile, ProviderDefaults, ProviderModeEntry, ProviderModelOverride, } from '../config/models.generated.js';
+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>;
+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;
+}>;

package/dist/provider/order.d.ts

@@ -1,3 +1,4 @@
 export declare const PROVIDER_ORDER: readonly ["codex", "claude", "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'),d=require('fs'),G=require('crypto'),q=require('js-yaml'),O=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 d__namespace=/*#__PURE__*/_interopNamespace(d);var G__namespace=/*#__PURE__*/_interopNamespace(G);var q__namespace=/*#__PURE__*/_interopNamespace(q);var O__namespace=/*#__PURE__*/_interopNamespace(O);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 E(e,t){try{return ae(t).test(e)}catch{return  false}}function P(e,...t){let r=e.split("/");if(r.length<t.length)return  false;let s=r.length-t.length;return t.every((n,i)=>E(r[s+i],n))}function ce(e,t){return e.split("/").some(r=>E(r,t))}var z=[{label:".env*",test:e=>E(e,".env*")},{label:".git/",test:(e,t,r)=>r&&e===".git"},{label:"memory/",test:(e,t,r)=>r&&e==="memory"},{label:"*.key",test:e=>E(e,"*.key")},{label:"*.pem",test:e=>E(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&&P(t,".crewx","threads")},{label:".crewx/crewx.db",test:(e,t,r)=>!r&&P(t,".crewx","crewx.db")},{label:".crewx/*.log",test:(e,t,r)=>!r&&P(t,".crewx","*.log")},{label:".crewx/publish/",test:(e,t,r)=>r&&P(t,".crewx","publish")},{label:".crewx/",test:(e,t)=>ce(t,".crewx")}];function U(e,t,r){for(let s of z)if(s.test(e,t,r))return s.label;return null}function J(e){let t=[],r=[];function s(n,i,a){let m;try{m=d__namespace.readdirSync(n,{withFileTypes:!0});}catch{return}m.sort((c,u)=>c.name.localeCompare(u.name));for(let c of m){let u=i?`${i}/${c.name}`:c.name,l=y__namespace.join(n,c.name);if(c.isSymbolicLink()){let p;try{p=d__namespace.statSync(l);}catch{continue}if(p.isDirectory()){r.push({path:u,rule:a??"symlink-dir"});continue}let C=a??U(c.name,u,false);C?r.push({path:u,rule:C}):t.push(u);continue}if(c.isDirectory()){let p=a??U(c.name,u,true);s(l,u,p);continue}if(c.isFile()){let p=a??U(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 V(e,t){let r=[];for(let s of t){let n=y__namespace.join(e,s),i;try{i=d__namespace.readFileSync(n);}catch{continue}if(le(i))continue;i.toString("utf8").split(/\r\n|\r|\n/).forEach((m,c)=>{for(let{rule:u,regex:l}of ue)l.test(m)&&r.push({path:s,line:c+1,rule:u});});}return r}var X=/^[a-z0-9-]+$/,pe=/^\d+\.\d+\.\d+(?:-[0-9A-Za-z.-]+)?(?:\+[0-9A-Za-z.-]+)?$/,fe=/^[A-Za-z_][A-Za-z0-9_]*$/;function me(e){let t=y__namespace.join(e,"crewx.yaml");if(!d__namespace.existsSync(t))return {};let r;try{r=q__namespace.load(d__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 he(e){return G__namespace.createHash("sha256").update(new Uint8Array(d__namespace.readFileSync(e))).digest("hex")}function W(e,t,r={}){let s=me(e),n=s.name??y__namespace.basename(e);if(!X.test(n))throw new Error(`publish: invalid name "${n}" \u2014 must match ${X} (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:[],m=[];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)}"`);m.push(l);}let c=t.map(l=>({path:l,sha256:he(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:m};return s.crewxMinVersion&&(u.crewxMinVersion=s.crewxMinVersion),u}async function Q(e,t){let r=y__namespace.join(e,".crewx","publish");d__namespace.mkdirSync(r,{recursive:true});let s=y__namespace.join(r,`${t.name}-${t.version}.tgz`),n=d__namespace.mkdtempSync(y__namespace.join(O__namespace.tmpdir(),"crewx-publish-"));try{d__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);d__namespace.mkdirSync(y__namespace.dirname(a),{recursive:!0}),d__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{d__namespace.rmSync(n,{recursive:true,force:true});}return s}var A="/api/v1";var ye=201,be=409,I=401;function we(){return process.env.WI013_FAKE_UPLOAD==="1"}function Ee(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("WI013_FAKE_UPLOAD: re-gzipped bytes are identical to the original \u2014 tamper is a no-op");return r}function Ae(e){return e.replace(/\/+$/,"")}async function v(e){try{return await e.json()}catch{return null}}function b(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: ${t} response envelope malformed (expected { success: true, data }) \u2014 HTTP ${r}`);return s.data}async function Se(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: submit \uC694\uCCAD\uC774 \uC2E4\uD328\uD588\uC2B5\uB2C8\uB2E4 (\uB124\uD2B8\uC6CC\uD06C) \u2014 ${o instanceof Error?o.message:String(o)}`)}let i;if(n.status===ye)i="created";else if(n.status===be)i="existing";else {if(n.status===I)throw new Error("publish: \uC778\uC99D\uC774 \uB9CC\uB8CC\uB418\uC5C8\uAC70\uB098 \uC5C6\uC2B5\uB2C8\uB2E4 \u2014 \uB2E4\uC2DC \uB85C\uADF8\uC778\uD558\uC138\uC694");{let o=await v(n);throw new Error(`publish: submit \uC2E4\uD328 \u2014 HTTP ${n.status}${b(o)?` ${b(o)}`:""}`)}}let a="not-needed",m=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: version \uC870\uD68C \uC694\uCCAD\uC774 \uC2E4\uD328\uD588\uC2B5\uB2C8\uB2E4 (\uB124\uD2B8\uC6CC\uD06C) \u2014 ${f instanceof Error?f.message:String(f)}`)}let M=await v(o);if(o.status!==200)throw new Error(`publish: publisher items \uC870\uD68C \uC2E4\uD328 \u2014 HTTP ${o.status}${b(M)?` ${b(M)}`:""}`);let H=ee(M,"publisher items",o.status)?.items;if(!Array.isArray(H))throw new Error(`publish: publisher items response malformed (expected data.items[]) \u2014 HTTP ${o.status}`);let $=H.find(f=>!f||typeof f!="object"?false:f.slug===s);if(!$||typeof $.version!="string")throw new Error(`publish: publisher items response does not contain slug "${s}" \u2014 HTTP ${o.status}`);if(m=$.version,m!==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(x){throw new Error(`publish: version update \uC694\uCCAD\uC774 \uC2E4\uD328\uD588\uC2B5\uB2C8\uB2E4 (\uB124\uD2B8\uC6CC\uD06C) \u2014 ${x instanceof Error?x.message:String(x)}`)}if(!f.ok){let x=await v(f),w=b(x);throw f.status===I?new Error(`publish: version update \uC778\uC99D\uC774 \uB9CC\uB8CC\uB418\uC5C8\uAC70\uB098 \uC5C6\uC2B5\uB2C8\uB2E4 \u2014 \uB2E4\uC2DC \uB85C\uADF8\uC778\uD558\uC138\uC694 (HTTP ${f.status})${w?` ${w}`:""}`):f.status===403?new Error(`publish: version update \uAD8C\uD55C\uC774 \uC5C6\uC2B5\uB2C8\uB2E4 \u2014 \uAE30\uC874 \uD56D\uBAA9\uC758 \uC18C\uC720\uC790\uB9CC \uBC84\uC804\uC744 \uAC31\uC2E0\uD560 \uC218 \uC788\uC2B5\uB2C8\uB2E4 (HTTP ${f.status})${w?` ${w}`:""}`):new Error(`publish: version update \uC2E4\uD328 \u2014 HTTP ${f.status}${w?` ${w}`:""}`)}a="applied";}}let c=d__namespace.readFileSync(e.tgzPath),u=we()?Ee(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: upload \uC694\uCCAD\uC774 \uC2E4\uD328\uD588\uC2B5\uB2C8\uB2E4 (\uB124\uD2B8\uC6CC\uD06C) \u2014 ${o instanceof Error?o.message:String(o)}`)}if(p.status===I)throw new Error("publish: \uC778\uC99D\uC774 \uB9CC\uB8CC\uB418\uC5C8\uAC70\uB098 \uC5C6\uC2B5\uB2C8\uB2E4 \u2014 \uB2E4\uC2DC \uB85C\uADF8\uC778\uD558\uC138\uC694");if(!p.ok){let o=await v(p);throw new Error(`publish: upload \uC2E4\uD328 \u2014 HTTP ${p.status}${b(o)?` ${b(o)}`:""}`)}let C=await v(p),F=ee(C,"upload",p.status);return {slug:s,version:e.manifest.version,artifactChecksum:F.artifactChecksum,artifactSizeBytes:F.artifactSizeBytes,submitOutcome:i,versionUpdate:a,serverVersionBefore:m}}function ne(){if(process.env.CREWX_HOME)try{return d__namespace.realpathSync(process.env.CREWX_HOME)}catch{return y__namespace.join(O__namespace.homedir(),".crewx")}return process.platform!=="win32"&&process.env.XDG_CONFIG_HOME?y__namespace.join(process.env.XDG_CONFIG_HOME,"crewx"):y__namespace.join(O__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 S(){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 S()}}function ie(e){if(typeof e!="string")return S();let t=e.split(".");if(t.length!==3||t.some(i=>i.length===0))return S();let r=se(t[0]),s=se(t[1]);if(!r||typeof r!="object"||!s||typeof s!="object")return S();let n=s;return typeof n.iss!="string"||n.iss.length===0||typeof n.sub!="string"||n.sub.length===0?S():{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 j(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 ve(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 Ce(){let e=y.join(ne(),"auth.json");if(!d.existsSync(e))throw new Error(`Login required \u2014 ${e} was not found (please log in first)`);let t;try{t=d.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(!ve(r))throw new Error(`auth.json is malformed (${e}) \u2014 please log in again`);let s=N();return j(r,s),r}async function Pe(e,t={}){let r=y__namespace.resolve(e),{included:s,excluded:n}=J(r),i=W(r,s,{version:t.version}),a=V(r,s);return {manifest:i,included:s,excluded:n,secretFindings:a}}async function pt(e,t={}){let r=await Pe(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=z;exports.MARKETPLACE_API_PREFIX=A;exports.assertAuthJsonUserRealm=j;exports.assertUserRealmAccessToken=oe;exports.decodeAccessTokenIdentity=ie;exports.packTemplate=pt;exports.planPublish=Pe;exports.readAuthJson=Ce;exports.resolveUserAccountConfig=N;exports.uploadToMarketplace=Se;

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/index.d.ts

@@ -11,7 +11,7 @@ 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, WorkflowCardRow, } from './task.repository.js';
 export { ThreadRepository } from './thread.repository.js';
 export type { ThreadRow, NewThread } from './thread.repository.js';
 export { SpanRepository } from './span.repository.js';
@@ -24,3 +24,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';