@xopcai/xopc 0.0.309 → 0.0.312

package/dist/src/connectors/cli/process.js

@@ -0,0 +1,100 @@
+import { init_paths_state, resolveStateDir } from "../../config/paths-state.js";
+import { spawnProcess } from "../../process/run-process.js";
+import { prepareCliAssets } from "./assets.js";
+import { isAbsolute, join, relative, sep } from "node:path";
+import { mkdir, realpath, stat } from "node:fs/promises";
+//#region src/connectors/cli/process.ts
+init_paths_state();
+const running = /* @__PURE__ */ new Map();
+function cancelCliContext(contextId) {
+	for (const handle of running.get(contextId) ?? []) handle.terminate("cancelled");
+}
+function cliRoot() {
+	return join(resolveStateDir(), "connectors", "cli");
+}
+function cliContextPath(id) {
+	if (!/^[a-zA-Z0-9_-]{1,128}$/.test(id)) throw new Error("Invalid CLI context ID.");
+	return join(cliRoot(), "contexts", id);
+}
+function cliEnvironment(adapter, contextPath) {
+	const env = {};
+	for (const name of [
+		"PATH",
+		"SystemRoot",
+		"WINDIR",
+		"TMPDIR",
+		"TEMP",
+		"TMP",
+		"HTTPS_PROXY",
+		"HTTP_PROXY",
+		"NO_PROXY",
+		"LANG"
+	]) if (process.env[name]) env[name] = process.env[name];
+	for (const [name, value] of Object.entries(adapter.environment ?? {})) {
+		if (!/^[A-Z][A-Z0-9_]*$/.test(name) || [
+			"HOME",
+			"USERPROFILE",
+			"PATH",
+			"NODE_OPTIONS",
+			"LD_PRELOAD",
+			"DYLD_INSERT_LIBRARIES",
+			adapter.configEnvironment,
+			adapter.dataEnvironment
+		].includes(name)) throw new Error("Reserved CLI environment variable.");
+		env[name] = value;
+	}
+	env[adapter.configEnvironment] = join(contextPath, "config");
+	if (adapter.dataEnvironment) env[adapter.dataEnvironment] = join(contextPath, "data");
+	env.HOME = join(contextPath, "home");
+	env.USERPROFILE = env.HOME;
+	env.NO_COLOR = "1";
+	return env;
+}
+async function startCliProcess(options) {
+	if (!isAbsolute(options.executable)) throw new Error("CLI executable must be an absolute path.");
+	const contextPath = cliContextPath(options.contextId);
+	for (const folder of [
+		"",
+		"config",
+		"data",
+		"home",
+		"files"
+	]) await mkdir(join(contextPath, folder), {
+		recursive: true,
+		mode: 448
+	});
+	await prepareCliAssets(options.adapter, join(contextPath, "config"));
+	options.signal?.throwIfAborted();
+	options.beforeSpawn?.();
+	const handle = spawnProcess({
+		program: options.executable,
+		args: options.args,
+		cwd: join(contextPath, "files"),
+		env: cliEnvironment(options.adapter, contextPath),
+		shell: false,
+		terminationPolicy: "tree",
+		timeoutMs: options.timeoutMs ?? 6e4,
+		maxOutputBytes: options.maxOutputBytes ?? 1024 * 1024,
+		signal: options.signal,
+		onOutput: options.onOutput
+	});
+	const active = running.get(options.contextId) ?? /* @__PURE__ */ new Set();
+	running.set(options.contextId, active);
+	active.add(handle);
+	handle.completion.finally(() => {
+		active.delete(handle);
+		if (!active.size) running.delete(options.contextId);
+	}).catch(() => void 0);
+	return handle;
+}
+async function resolveCliArtifact(contextId, filePath) {
+	const root = await realpath(join(cliContextPath(contextId), "files"));
+	const resolved = await realpath(filePath);
+	const child = relative(root, resolved);
+	if (!child || child === ".." || child.startsWith(`..${sep}`) || isAbsolute(child)) throw new Error("CLI artifact is outside its context.");
+	const info = await stat(resolved);
+	if (!info.isFile() || info.size > 25 * 1024 * 1024) throw new Error("Invalid CLI artifact.");
+	return resolved;
+}
+//#endregion
+export { cancelCliContext, cliContextPath, cliEnvironment, cliRoot, resolveCliArtifact, startCliProcess };

package/dist/src/connectors/cli/protocol.d.ts

@@ -0,0 +1,10 @@
+import type { ProcessResult } from '../../process/process-spec.js';
+import type { CliAction, CliAdapter, CliResult, JsonObject } from './types.js';
+export declare class CliProtocolError extends Error {
+}
+export declare function object(value: unknown): JsonObject;
+export declare function parseJson(text: string): unknown;
+export declare function actionRevision(value: unknown): string;
+export declare function validateActionInput(action: CliAction, input: JsonObject): void;
+export declare function normalizeCliResult(adapter: Pick<CliAdapter, 'decodeResult'>, output: ProcessResult, scope: CliAction['scope']): CliResult;
+export declare function closedSchema(value: unknown): JsonObject;

package/dist/src/connectors/cli/protocol.js

@@ -0,0 +1,63 @@
+import { createHash } from "node:crypto";
+import Ajv from "ajv";
+//#region src/connectors/cli/protocol.ts
+const ajv = new Ajv({
+	strict: false,
+	allErrors: true,
+	validateFormats: false,
+	ownProperties: true
+});
+var CliProtocolError = class extends Error {};
+function object(value) {
+	if (!value || typeof value !== "object" || Array.isArray(value)) throw new CliProtocolError("Expected a JSON object.");
+	return value;
+}
+function parseJson(text) {
+	return JSON.parse(text);
+}
+function actionRevision(value) {
+	return createHash("sha256").update(JSON.stringify(value)).digest("hex");
+}
+function validateActionInput(action, input) {
+	const validate = ajv.compile(action.inputSchema);
+	if (!validate(input)) throw new Error(`Invalid action input: ${ajv.errorsText(validate.errors)}`);
+}
+function normalizeCliResult(adapter, output, scope) {
+	const uncertain = scope !== "read" && !output.spawnErrorCode;
+	if (output.timedOut || output.aborted || output.spawnErrorCode || output.outputTruncated) {
+		const kind = output.timedOut ? "timeout" : output.aborted ? "cancelled" : output.spawnErrorCode ? "startup" : "protocol";
+		return {
+			outcome: uncertain ? "unknown" : "failed",
+			error: {
+				kind,
+				message: `CLI execution ${kind}.`
+			}
+		};
+	}
+	try {
+		const data = adapter.decodeResult(output);
+		if (output.exitCode !== 0) throw new Error("CLI exited unsuccessfully.");
+		return {
+			outcome: "success",
+			data
+		};
+	} catch (error) {
+		const protocolError = error instanceof SyntaxError || error instanceof CliProtocolError;
+		return {
+			outcome: uncertain && (protocolError || output.signal !== null) ? "unknown" : "failed",
+			error: {
+				kind: protocolError ? "protocol" : "provider",
+				message: error instanceof Error ? error.message : "CLI failed."
+			}
+		};
+	}
+}
+function closedSchema(value) {
+	const schema = structuredClone(object(value));
+	if (schema.type !== "object") throw new Error("Action input must be an object schema.");
+	schema.additionalProperties = false;
+	ajv.compile(schema);
+	return schema;
+}
+//#endregion
+export { CliProtocolError, actionRevision, closedSchema, normalizeCliResult, object, parseJson, validateActionInput };

package/dist/src/connectors/cli/runtime.d.ts

@@ -0,0 +1,10 @@
+import type { Config } from '../../config/schema.js';
+import type { ConnectorConnection } from '../types.js';
+import type { CliAction, JsonObject } from './types.js';
+export declare function describeCliAction(config: Config, instanceId: string, connection: ConnectorConnection, actionId: string): Promise<CliAction>;
+export declare function verifyCliConnection(config: Config, instanceId: string, connection: ConnectorConnection, signal?: AbortSignal): Promise<{
+    adapter: import("./types.js").CliAdapter;
+    executable: string;
+    identity: import("./types.js").CliIdentity;
+}>;
+export declare function executeCliAction(config: Config, instanceId: string, connection: ConnectorConnection, action: CliAction, input: JsonObject, signal?: AbortSignal, beforeExecute?: () => void): Promise<import("./types.js").CliResult>;

package/dist/src/connectors/cli/runtime.js

@@ -0,0 +1,93 @@
+import { getConnectorAccount, init_connector_account_repository } from "../../storage/sqlite/connector-account-repository.js";
+import { startCliProcess } from "./process.js";
+import { normalizeCliResult, parseJson, validateActionInput } from "./protocol.js";
+import { verifyInstalledCli } from "./installer.js";
+import { requireCliInstance } from "./authorization.js";
+//#region src/connectors/cli/runtime.ts
+init_connector_account_repository();
+const contracts = /* @__PURE__ */ new Map();
+async function describeCliAction(config, instanceId, connection, actionId) {
+	const adapter = requireCliInstance(config, instanceId);
+	if (!adapter.curatedActions[actionId]) throw new Error("CLI action is not enabled.");
+	if (connection.provider !== "cli" || connection.metadata.runtimeInstanceId !== instanceId || connection.status !== "active") throw new Error("CLI connection is not available.");
+	const staticAction = adapter.staticActions?.[actionId];
+	if (staticAction) return staticAction;
+	const key = JSON.stringify([
+		instanceId,
+		connection.id,
+		connection.updatedAt,
+		adapter.version,
+		adapter.binaryVersion,
+		actionId
+	]);
+	const cached = contracts.get(key);
+	if (cached && cached.expiresAt > Date.now()) return cached.action;
+	const output = await (await startCliProcess({
+		adapter,
+		executable: await verifyInstalledCli(adapter),
+		contextId: String(connection.metadata.contextId),
+		args: adapter.schemaArgs(actionId)
+	})).completion;
+	if (output.exitCode !== 0 || output.outputTruncated) throw new Error("Could not retrieve CLI action schema.");
+	const action = adapter.decodeSchema(actionId, parseJson(output.stdout));
+	if (contracts.size >= 256) contracts.clear();
+	contracts.set(key, {
+		action,
+		expiresAt: Date.now() + 6e4
+	});
+	return action;
+}
+async function verifyCliConnection(config, instanceId, connection, signal) {
+	const adapter = requireCliInstance(config, instanceId);
+	if (connection.provider !== "cli" || connection.status !== "active" || connection.metadata.runtimeInstanceId !== instanceId) throw new Error("CLI connection is unavailable.");
+	const executable = await verifyInstalledCli(adapter);
+	const output = await (await startCliProcess({
+		adapter,
+		executable,
+		contextId: String(connection.metadata.contextId),
+		args: adapter.statusArgs,
+		signal
+	})).completion;
+	if (output.timedOut || output.aborted || output.outputTruncated) throw new Error("CLI identity verification failed.");
+	const identity = adapter.decodeIdentity(output);
+	if (identity.key !== getConnectorAccount(connection.accountId)?.identityKey) throw new Error("CLI identity changed. Reauthorize the selected account.");
+	return {
+		adapter,
+		executable,
+		identity
+	};
+}
+const queues = /* @__PURE__ */ new Map();
+async function executeCliAction(config, instanceId, connection, action, input, signal, beforeExecute) {
+	const contextId = String(connection.metadata.contextId);
+	const previous = queues.get(contextId) ?? Promise.resolve();
+	let release;
+	const pending = new Promise((resolve) => {
+		release = resolve;
+	});
+	queues.set(contextId, pending);
+	await previous;
+	try {
+		signal?.throwIfAborted();
+		validateActionInput(action, input);
+		const { adapter, executable, identity } = await verifyCliConnection(config, instanceId, connection, signal);
+		if (action.requiredScopes.some((scope) => !identity.scopes.includes(scope)) || action.anyScopes?.length && !action.anyScopes.some((scope) => identity.scopes.includes(scope))) throw new Error("CLI account is missing required scopes.");
+		if (adapter.curatedActions[action.id] !== action.scope) throw new Error("CLI action contract changed.");
+		return normalizeCliResult(adapter, await (await startCliProcess({
+			adapter,
+			executable,
+			contextId,
+			args: adapter.actionArgs(action, input),
+			signal,
+			beforeSpawn: () => {
+				requireCliInstance(config, instanceId);
+				beforeExecute?.();
+			}
+		})).completion, action.scope);
+	} finally {
+		release();
+		if (queues.get(contextId) === pending) queues.delete(contextId);
+	}
+}
+//#endregion
+export { describeCliAction, executeCliAction, verifyCliConnection };

package/dist/src/connectors/cli/store.d.ts

@@ -0,0 +1,35 @@
+import type { CliChallenge, CliIdentity } from './types.js';
+export declare const cliOwnerId: string;
+export type CliAuthorization = {
+    id: string;
+    instance_id: string;
+    connector_id: string;
+    principal_id: string;
+    expected_account_id: string | null;
+    context_id: string;
+    phase: 'preparing' | 'awaiting_user' | 'verifying' | 'succeeded' | 'failed' | 'expired' | 'cancelled';
+    challenge_json: string | null;
+    error: string | null;
+    account_id: string | null;
+    owner_id: string;
+    expires_at: number;
+    updated_at: number;
+};
+export declare function readCliAuthorization(id: string, principalId?: string): CliAuthorization | undefined;
+export declare function createCliAuthorization(instanceId: string, connectorId: string, expectedAccountId?: string): CliAuthorization;
+export declare function updateCliAuthorization(id: string, input: {
+    phase: CliAuthorization['phase'];
+    challenge?: CliChallenge;
+    error?: string;
+    accountId?: string;
+}): boolean;
+export declare function commitCliIdentity(attempt: CliAuthorization, identity: CliIdentity): string;
+export declare function cliAuthorizationView(row: CliAuthorization): {
+    id: string;
+    status: "failed" | "succeeded" | "expired" | "cancelled" | "verifying" | "awaiting_user" | "preparing";
+    challenge: CliChallenge;
+    error: string;
+    accountId: string;
+    expiresAt: number;
+};
+export declare function recoverCliExecutions(): void;

package/dist/src/connectors/cli/store.js

@@ -0,0 +1,121 @@
+import { getSqliteDatabase, init_transaction, runSqliteWriteTransaction } from "../../storage/sqlite/transaction.js";
+import { getConnectorAccount, init_connector_account_repository } from "../../storage/sqlite/connector-account-repository.js";
+import { init_connector_repository, upsertConnectorConnection } from "../../storage/sqlite/connector-repository.js";
+import { randomUUID } from "node:crypto";
+//#region src/connectors/cli/store.ts
+init_transaction();
+init_connector_account_repository();
+init_connector_repository();
+const cliOwnerId = `${process.pid}:${randomUUID()}`;
+function ownerAlive(ownerId) {
+	if (ownerId === cliOwnerId) return true;
+	const pid = Number(ownerId.split(":")[0]);
+	if (!Number.isSafeInteger(pid) || pid <= 0) return false;
+	try {
+		process.kill(pid, 0);
+		return true;
+	} catch (error) {
+		return error.code === "EPERM";
+	}
+}
+function readCliAuthorization(id, principalId = "local-owner") {
+	const row = getSqliteDatabase().prepare("SELECT * FROM connector_cli_authorizations WHERE id = ? AND principal_id = ?").get(id, principalId);
+	if (row && [
+		"preparing",
+		"awaiting_user",
+		"verifying"
+	].includes(row.phase) && (row.expires_at <= Date.now() || !ownerAlive(row.owner_id))) {
+		const phase = row.expires_at <= Date.now() ? "expired" : "failed";
+		updateCliAuthorization(row.id, {
+			phase,
+			error: phase === "expired" ? "Authorization expired." : "Gateway restarted. Start authorization again."
+		});
+		return {
+			...row,
+			phase,
+			challenge_json: null,
+			error: "Start authorization again."
+		};
+	}
+	return row;
+}
+function createCliAuthorization(instanceId, connectorId, expectedAccountId) {
+	const db = getSqliteDatabase();
+	const pending = db.prepare("SELECT id FROM connector_cli_authorizations WHERE instance_id = ? AND principal_id = 'local-owner' AND phase IN ('preparing','awaiting_user','verifying')").get(instanceId);
+	if (pending) {
+		const current = readCliAuthorization(pending.id);
+		if (current && [
+			"preparing",
+			"awaiting_user",
+			"verifying"
+		].includes(current.phase)) throw new Error("Authorization is already in progress.");
+	}
+	if (expectedAccountId) {
+		const account = getConnectorAccount(expectedAccountId);
+		if (!account || account.principalId !== "local-owner" || account.connectorId !== connectorId || account.runtimeInstanceId !== instanceId) throw new Error("Account not found.");
+	}
+	const id = randomUUID();
+	db.prepare(`INSERT INTO connector_cli_authorizations
+    (id, instance_id, connector_id, principal_id, expected_account_id, context_id, phase, owner_id, expires_at, updated_at)
+    VALUES (?, ?, ?, 'local-owner', ?, ?, 'preparing', ?, ?, ?)`).run(id, instanceId, connectorId, expectedAccountId ?? null, id, cliOwnerId, Date.now() + 10 * 6e4, Date.now());
+	return readCliAuthorization(id);
+}
+function updateCliAuthorization(id, input) {
+	return getSqliteDatabase().prepare(`UPDATE connector_cli_authorizations SET phase = ?, challenge_json = ?, error = ?, account_id = COALESCE(?, account_id), updated_at = ?
+    WHERE id = ? AND phase IN ('preparing','awaiting_user','verifying')`).run(input.phase, input.challenge ? JSON.stringify(input.challenge) : null, input.error ?? null, input.accountId ?? null, Date.now(), id).changes > 0;
+}
+function commitCliIdentity(attempt, identity) {
+	return runSqliteWriteTransaction((db) => {
+		const current = readCliAuthorization(attempt.id);
+		if (!current || current.phase !== "verifying") throw new Error("Authorization is no longer active.");
+		const previous = attempt.expected_account_id ? getConnectorAccount(attempt.expected_account_id) : void 0;
+		if (attempt.expected_account_id && (!previous || previous.principalId !== attempt.principal_id || previous.runtimeInstanceId !== attempt.instance_id)) throw new Error("Selected account is no longer available.");
+		if (previous && previous.identityKey !== identity.key) throw new Error("Authorized identity does not match the selected account.");
+		const match = db.prepare("SELECT id FROM connector_accounts WHERE principal_id = ? AND runtime_instance_id = ? AND identity_key = ?").get(attempt.principal_id, attempt.instance_id, identity.key);
+		const accountId = previous?.id ?? match?.id ?? randomUUID();
+		const connectionId = randomUUID();
+		upsertConnectorConnection({
+			id: connectionId,
+			accountId,
+			installationId: `${attempt.connector_id}-local-owner`,
+			connectorId: attempt.connector_id,
+			provider: "cli",
+			principalId: attempt.principal_id,
+			providerConnectionId: attempt.context_id,
+			identity: identity.identity,
+			status: "active",
+			isDefault: false,
+			connectedAt: (/* @__PURE__ */ new Date()).toISOString(),
+			metadata: {
+				runtimeInstanceId: attempt.instance_id,
+				contextId: attempt.context_id,
+				scopes: identity.scopes
+			}
+		});
+		db.prepare(`UPDATE connector_accounts SET runtime_instance_id = ?, identity_key = ?, identity_json = ?,
+      enabled = 1, label = COALESCE(label, ?), current_connection_id = ?, updated_at = ? WHERE id = ?`).run(attempt.instance_id, identity.key, JSON.stringify(identity.identity), identity.label, connectionId, (/* @__PURE__ */ new Date()).toISOString(), accountId);
+		db.prepare("UPDATE connector_connections SET status = 'disabled' WHERE account_id = ? AND id <> ? AND provider = 'cli'").run(accountId, connectionId);
+		updateCliAuthorization(attempt.id, {
+			phase: "succeeded",
+			accountId
+		});
+		return accountId;
+	});
+}
+function cliAuthorizationView(row) {
+	return {
+		id: row.id,
+		status: row.phase,
+		challenge: row.challenge_json ? JSON.parse(row.challenge_json) : void 0,
+		error: row.error ?? void 0,
+		accountId: row.account_id ?? void 0,
+		expiresAt: row.expires_at
+	};
+}
+function recoverCliExecutions() {
+	const db = getSqliteDatabase();
+	const owners = db.prepare("SELECT DISTINCT owner_id FROM connector_cli_executions WHERE status = 'running' AND owner_id <> ?").all(cliOwnerId);
+	for (const owner of owners) if (!ownerAlive(owner.owner_id)) db.prepare("UPDATE connector_cli_executions SET status = 'unknown', error_kind = 'interrupted', finished_at = ? WHERE status = 'running' AND owner_id = ?").run(Date.now(), owner.owner_id);
+}
+//#endregion
+export { cliAuthorizationView, cliOwnerId, commitCliIdentity, createCliAuthorization, readCliAuthorization, recoverCliExecutions, updateCliAuthorization };

package/dist/src/connectors/cli/types.d.ts

@@ -0,0 +1,73 @@
+import type { ProcessResult } from '../../process/process-spec.js';
+import type { ConnectorScope } from '../types.js';
+export type JsonObject = Record<string, unknown>;
+export type CliAction = {
+    id: string;
+    description: string;
+    inputSchema: JsonObject;
+    scope: ConnectorScope;
+    requiredScopes: string[];
+    anyScopes?: string[];
+    revision: string;
+};
+export type CliIdentity = {
+    key: string;
+    label: string;
+    scopes: string[];
+    identity: JsonObject;
+};
+export type CliChallenge = ({
+    type: 'open_url';
+    url: string;
+} | {
+    type: 'qr_code';
+    artifactId: string;
+}) & {
+    step: number;
+    totalSteps: number;
+};
+export type CliResult = {
+    outcome: 'success' | 'failed' | 'unknown';
+    data?: unknown;
+    error?: {
+        kind: 'protocol' | 'provider' | 'timeout' | 'cancelled' | 'startup' | 'unauthorized';
+        message: string;
+        code?: string;
+    };
+};
+export type CliDistribution = {
+    url: string;
+    integrity: string;
+    archiveEntry: string;
+};
+export type CliAdapter = {
+    id: string;
+    version: string;
+    binaryVersion: string;
+    executable: string;
+    distributions: Record<string, CliDistribution>;
+    configEnvironment: string;
+    environment?: Readonly<Record<string, string>>;
+    configAssets?: ReadonlyArray<{
+        path: string;
+        content: string;
+        sha256: string;
+    }>;
+    dataEnvironment?: string;
+    curatedActions: Record<string, ConnectorScope>;
+    staticActions?: Record<string, CliAction>;
+    schemaArgs(actionId: string): string[];
+    decodeSchema(actionId: string, value: unknown): CliAction;
+    actionArgs(action: CliAction, input: JsonObject): string[];
+    decodeResult(output: ProcessResult): unknown;
+    statusArgs: string[];
+    decodeIdentity(output: ProcessResult): CliIdentity;
+    authorizationSteps: Array<{
+        args: string[];
+        challenge: 'url' | 'qr';
+        initialOnly?: boolean;
+        decodeResult?: (output: ProcessResult) => void;
+        urlHosts?: string[];
+        urlField?: string;
+    }>;
+};

package/dist/src/connectors/composio-backends.js

@@ -47,7 +47,7 @@ async function ensureComposioBackend(resolver = new CredentialResolver()) {
 		credentialRef: storedKey ? "connector-composio-api-key" : envRef,
 		credentialSource: !storedKey && envRef ? "environment" : "stored"
 	});
-	getSqliteDatabase().prepare("UPDATE connector_accounts SET backend_id = ? WHERE backend_id IS NULL").run(backend.id);
+	getSqliteDatabase().prepare("UPDATE connector_accounts SET backend_id = ? WHERE backend_id IS NULL AND runtime_instance_id IS NULL").run(backend.id);
 	activateComposioBackend(backend.id);
 	return getComposioBackend(backend.id);
 }

package/dist/src/connectors/composio-sessions.d.ts

@@ -59,6 +59,7 @@ export declare class ComposioSessionsAdapter {
     revokeConnection(connection: ConnectorConnection): Promise<void>;
     refreshConnection(connection: ConnectorConnection): Promise<ConnectorConnection>;
     executeWithPolicy(input: {
+        signal?: AbortSignal;
         context: ComposioSessionContext;
         installation: ConnectorInstallationPolicy;
         connection?: ConnectorConnection;

package/dist/src/connectors/composio-sessions.js

@@ -4,11 +4,11 @@ import { getSqliteDatabase, init_transaction } from "../storage/sqlite/transacti
 import { getConnectorAccount, init_connector_account_repository, reconcileConnectorAccount } from "../storage/sqlite/connector-account-repository.js";
 import { appendConnectorExecutionAudit, getConnectorConnection, getConnectorInstallation, init_connector_repository, listConnectorConnections, upsertConnectorConnection } from "../storage/sqlite/connector-repository.js";
 import { CredentialResolver, init_credentials } from "../auth/credentials.js";
+import { canAccessConnectorAccount } from "./account-access.js";
 import { ensureComposioBackend, getComposioBackend, listComposioBackends, resolveBackendKey } from "./composio-backends.js";
 import { saveAuthorizationAttempt } from "./authorization-attempts.js";
 import { connectorIdentityKey, mergeConnectorIdentity } from "./connector-identity.js";
 import { evaluateConnectorExecutionPolicy } from "./policy.js";
-import { canAccessConnectorAccount } from "./account-access.js";
 import { createHash } from "node:crypto";
 //#region src/connectors/composio-sessions.ts
 init_credentials();
@@ -393,6 +393,7 @@ var ComposioSessionsAdapter = class {
 		return synced.find((candidate) => candidate.id === connection.id) ?? synced.find((candidate) => candidate.providerConnectionId === connection.providerConnectionId) ?? connection;
 	}
 	async executeWithPolicy(input) {
+		input.signal?.throwIfAborted();
 		if (!input.connection || input.connection.status !== "active" || !canAccessConnectorAccount(input.connection, input.installation, input.agentId)) return {
 			decision: "denied",
 			reason: "Account is unavailable to this agent."
@@ -430,13 +431,16 @@ var ComposioSessionsAdapter = class {
 			const providerPrincipalId = input.connection?.metadata.providerPrincipalId;
 			const connectionAuthConfigId = input.connection?.metadata.authConfigId;
 			if (input.connection && (typeof providerPrincipalId !== "string" || !providerPrincipalId.trim())) throw new Error("Connected account is missing its provider identity. Reconnect the account and try again.");
-			const result = await (await this.createSession({
+			const session = await this.createSession({
 				...input.context,
 				backendId: input.connection?.accountId ? getConnectorAccount(input.connection.accountId)?.backendId : input.context.backendId,
 				connectedAccounts,
 				...toolkit && typeof connectionAuthConfigId === "string" && connectionAuthConfigId.trim() ? { authConfigs: { [toolkit]: connectionAuthConfigId.trim() } } : { authConfigs: void 0 },
 				...typeof providerPrincipalId === "string" ? { providerPrincipalId } : {}
-			})).execute(input.action.actionId, input.args ?? {}, input.connection ? { account: input.connection.providerConnectionId } : void 0);
+			});
+			input.signal?.throwIfAborted();
+			const result = await session.execute(input.action.actionId, input.args ?? {}, input.connection ? { account: input.connection.providerConnectionId } : void 0);
+			input.signal?.throwIfAborted();
 			appendConnectorExecutionAudit({
 				installationId: input.installation.id,
 				connectionId: input.connection?.id,
@@ -455,6 +459,7 @@ var ComposioSessionsAdapter = class {
 				result
 			};
 		} catch (err) {
+			input.signal?.throwIfAborted();
 			const errorCode = err && typeof err === "object" && "code" in err ? String(err.code) : void 0;
 			appendConnectorExecutionAudit({
 				installationId: input.installation.id,

package/dist/src/connectors/composio.js

@@ -1,9 +1,9 @@
 import { getConnectorAccount, init_connector_account_repository, refreshConnectorAccountCurrent, updateConnectorAccount } from "../storage/sqlite/connector-account-repository.js";
 import { getConnectorConnection, getConnectorInstallation, init_connector_repository, listConnectorConnections, upsertConnectorActionMetadata, upsertConnectorConnection, upsertConnectorInstallation } from "../storage/sqlite/connector-repository.js";
 import { CredentialResolver, init_credentials } from "../auth/credentials.js";
+import { canAccessConnectorAccount, currentAccountConnections } from "./account-access.js";
 import { activateComposioBackend, addComposioBackend, ensureComposioBackend, getComposioBackend, listComposioBackends, markComposioBackendVerified, resolveBackendKey } from "./composio-backends.js";
 import { connectorIdentityKey } from "./connector-identity.js";
-import { canAccessConnectorAccount, currentAccountConnections } from "./account-access.js";
 import { ComposioSessionsAdapter, assertComposioAccessConfigured } from "./composio-sessions.js";
 import { getConnectorLearningPlan } from "./learning-recipes.js";
 import { COMPOSIO_AGENT_READY_TOOLKITS, COMPOSIO_TOOLKIT_DISPLAY_NAMES, connectorDefinitionFromComposioToolkit } from "./composio-catalog.js";

package/dist/src/connectors/connection-candidates.js

@@ -1,4 +1,5 @@
-import { getConnectorDefinition } from "./catalog.js";
+import { getCliAdapter } from "./cli/adapterRegistry.js";
+import { getConnectorDefinition, listConnectorCatalog } from "./catalog.js";
 //#region src/connectors/connection-candidates.ts
 const CANDIDATES = [
 	{
@@ -33,7 +34,18 @@ const CANDIDATES = [
 	}
 ];
 function connectionCandidates(query) {
-	return CANDIDATES.filter((item) => item.pattern.test(query)).flatMap((item) => {
+	return [...listConnectorCatalog().filter((definition) => definition.runtime.type === "cli" && [
+		definition.id,
+		definition.displayName,
+		...definition.tags ?? []
+	].some((term) => term.toLowerCase().includes(query.toLowerCase().trim()) || query.toLowerCase().includes(term.toLowerCase()))).map((definition) => {
+		const candidate = resolveConnectionCandidate(definition.id);
+		return {
+			candidateRef: definition.id,
+			label: candidate.label,
+			capabilities: candidate.capabilities
+		};
+	}), ...CANDIDATES.filter((item) => item.pattern.test(query)).flatMap((item) => {
 		const connectorId = `composio-${item.toolkit}`;
 		const definition = getConnectorDefinition(connectorId);
 		return definition ? [{
@@ -41,9 +53,16 @@ function connectionCandidates(query) {
 			label: definition.displayName,
 			capabilities: item.capabilities
 		}] : [];
-	});
+	})];
 }
 function resolveConnectionCandidate(ref) {
+	const cli = getConnectorDefinition(ref);
+	if (cli?.runtime.type === "cli") return {
+		key: `${ref}:default`,
+		connectorId: ref,
+		label: cli.displayName,
+		capabilities: Object.entries(getCliAdapter(cli.runtime.adapterId).curatedActions).filter(([, scope]) => scope === "read").map(([id]) => id)
+	};
 	const item = CANDIDATES.find((item) => `composio-${item.toolkit}` === ref);
 	const definition = item ? getConnectorDefinition(ref) : void 0;
 	if (!item || !definition) throw new Error("Unknown connection candidate. Search for a supported app first.");

package/dist/src/connectors/connection-recovery-service.d.ts

@@ -35,6 +35,7 @@ export declare class ConnectionRecoveryService {
     private view;
     private ensureInstallation;
     private checkCapabilities;
+    private syncConnections;
     preflight(input: SessionInput): Promise<boolean>;
     act(conversationId: string, action: ConnectionAction): Promise<{
         snapshot: ConnectionWaitSnapshot;