@chengxianglibra/dsh-data-analysis 0.1.1 → 0.2.0

package/lib/compatibility.js

@@ -46,7 +46,7 @@ function parsePackageManifest(value) {
                 packageSpec: requiredString(marivo.packageSpec, 'package compatibility marivo.packageSpec'),
             }),
             contracts: Object.freeze({
-                runtimeInstallation: requiredLiteral(contracts.runtimeInstallation, 'dsh-data-analysis-runtime/v2', 'package compatibility contracts.runtimeInstallation'),
+                runtimeInstallation: requiredLiteral(contracts.runtimeInstallation, 'dsh-data-analysis-runtime/v3', 'package compatibility contracts.runtimeInstallation'),
                 subprocessPolicy: requiredLiteral(contracts.subprocessPolicy, 'direct-argv-inherited-env-snapshot-overlay-v2', 'package compatibility contracts.subprocessPolicy'),
             }),
         }),
@@ -56,7 +56,7 @@ const packageManifest = parsePackageManifest(createRequire(import.meta.url)('../
 /** The package semver and the compatibility contract shipped in this exact installation. */
 export const PLUGIN_VERSION = packageManifest.version;
 export const DSH_DATA_ANALYSIS_COMPATIBILITY = packageManifest.dshDataAnalysisCompatibility;
-/** Every DSH peer is required and must use this one verified release. */
+/** Every DSH peer is required and must satisfy this declared compatibility range. */
 export const DSH_PEER_RANGE = DSH_DATA_ANALYSIS_COMPATIBILITY.dsh.peerRange;
 export const DSH_DISTRIBUTION = DSH_DATA_ANALYSIS_COMPATIBILITY.dsh.distribution;
 export const DSH_PEER_DEPENDENCIES = Object.freeze(Object.fromEntries(Object.entries(packageManifest.peerDependencies).filter(([name]) => name.startsWith('@deepseek-ai/dsh-'))));

package/lib/datasource/authoring.js

@@ -0,0 +1,109 @@
+import { z } from 'zod';
+export const datasourceAuthoringSchema = z.object({
+    fingerprint: z.string(),
+    backends: z.array(z.object({
+        name: z.string(),
+        fields: z.array(z.object({
+            name: z.string(),
+            type: z.enum(['string', 'number', 'boolean', 'json']),
+            required: z.boolean(),
+            description: z.string(),
+            default: z.unknown().optional(),
+        })),
+    })),
+});
+// The public DatasourceSpec union and dataclass fields are read from the checked Runtime.
+// No backend registry or field schema is duplicated in the plugin.
+export const DATASOURCE_AUTHORING_PROGRAM = String.raw `
+import contextlib
+import dataclasses
+import hashlib
+import json
+import sys
+import typing
+import marivo.datasource as md
+
+class Discard:
+    def write(self, value): return len(value)
+    def flush(self): pass
+
+def spec_fields(cls):
+    hints = typing.get_type_hints(cls)
+    result = []
+    for field in dataclasses.fields(cls):
+        if not field.init or field.name == "ai_context":
+            continue
+        annotation = hints[field.name]
+        types = set(typing.get_args(annotation) or [annotation]) - {type(None)}
+        kind = "string" if types == {str} else "boolean" if types == {bool} else "number" if types <= {int, float} else "json"
+        item = {"name": field.name, "type": kind,
+            "required": field.default is dataclasses.MISSING and field.default_factory is dataclasses.MISSING,
+            "description": field.metadata.get("description", "")}
+        if field.default is not dataclasses.MISSING:
+            item["default"] = field.default
+        result.append(item)
+    return result
+
+def configuration(name, cls):
+    import marivo.semantic as ms
+    description = md.describe(name)
+    details = ms.load().datasources.get(name).details()
+    if details.backend_type != description.backend_type or dict(details.fields) != description.literal_fields or dict(details.env_refs) != description.env_refs:
+        raise ValueError("context-changed")
+    context = {"business_definition": details.context.business_definition,
+        "guardrails": list(details.context.guardrails)}
+    allowed = {field["name"] for field in spec_fields(cls)}
+    fields = {"name": name}
+    extra = {}
+    for key, value in description.literal_fields.items():
+        if key in allowed and key != "extra": fields[key] = value
+        else: extra[key] = value
+    if extra: fields["extra"] = extra
+    for key, value in description.env_refs.items():
+        if key.startswith("http_header:"):
+            fields.setdefault("http_headers_env", {})[key.removeprefix("http_header:")] = value
+        elif key + "_env" in allowed: fields[key + "_env"] = value
+        else: raise ValueError("datasource-definition-invalid")
+    version = hashlib.sha256(json.dumps([description.backend_type, fields, context], sort_keys=True).encode()).hexdigest()
+    return {"name": name, "backend": description.backend_type, "fields": fields, "version": version}, context
+
+try:
+    payload = json.load(sys.stdin)
+    with contextlib.redirect_stdout(Discard()), contextlib.redirect_stderr(Discard()):
+        specs = {cls.backend_type: cls for cls in typing.get_args(md.DatasourceSpec)}
+        if payload["action"] == "schema":
+            result = {"backends": [{"name": key, "fields": spec_fields(cls)} for key, cls in specs.items()]}
+        elif payload["action"] == "read":
+            description = md.describe(payload["name"])
+            result, _ = configuration(payload["name"], specs[description.backend_type])
+        else:
+            cls = specs[payload["backend"]]
+            fields = payload["fields"]
+            allowed = {field["name"] for field in spec_fields(cls)}
+            context = None
+            if payload["action"] == "update":
+                current = md.describe(payload["name"])
+                if fields.get("name") != payload["name"] or current.backend_type != payload["backend"]:
+                    raise ValueError("datasource-identity-fixed")
+                original, context = configuration(payload["name"], cls)
+                if original["version"] != payload["version"]:
+                    raise ValueError("datasource-config-changed")
+            if set(fields) - allowed:
+                raise ValueError("unknown-field")
+            spec = cls(**fields)
+            if payload["action"] == "create" and any(item.name == spec.name for item in md.list()):
+                result = {"error": "datasource-already-exists"}
+            else:
+                if sorted(spec.env_refs.values()) != sorted(payload["refs"]):
+                    raise ValueError("credential-reference-mismatch")
+                if context is not None:
+                    import marivo.semantic as ms
+                    spec = cls(**fields, ai_context=ms.ai_context(**context))
+                md.register(spec)
+                result = {"name": spec.name}
+
+except Exception as exc:
+    code = str(exc)
+    result = {"error": code if code in ("datasource-config-changed", "datasource-identity-fixed", "context-changed") else "datasource-definition-invalid"}
+print(json.dumps(result))
+`.trim();

package/lib/datasource/bridge-programs.js

@@ -1,31 +1,48 @@
-export const MARIVO_DATASOURCE_DESCRIBE_PROGRAM = String.raw `
+import { RESOLVER_PROGRAM } from "./resolver-program.js";
+const DATASOURCE_DESCRIPTION_PROGRAM = String.raw `
 import json
 import os
 import sys
 import marivo
 import marivo.datasource as md
 
-description = md.describe(sys.argv[1])
-print(json.dumps({
-    "name": description.name,
-    "refs": list(description.env_refs.values()),
-}, sort_keys=True))
-`.trim();
-export const MARIVO_DATASOURCE_INVENTORY_PROGRAM = String.raw `
-import json
-import os
-import sys
-import marivo
-import marivo.datasource as md
+import hashlib
+
+def project_description(description):
+    payload = {"name": description.name, "backend": description.backend_type,
+        "fields": description.literal_fields, "refs": description.env_refs}
+    return {"name": description.name, "backend": description.backend_type,
+        "properties": description.literal_fields, "refs": list(description.env_refs.values()),
+        "fields": description.env_refs,
+        "definition": hashlib.sha256(json.dumps(payload, sort_keys=True, default=str).encode()).hexdigest()}
 
+`.trim();
+export const MARIVO_DATASOURCE_DESCRIBE_PROGRAM = `${DATASOURCE_DESCRIPTION_PROGRAM}
+print(json.dumps(project_description(md.describe(sys.argv[1])), sort_keys=True))`;
+export const MARIVO_DATASOURCE_REMOVE_PROGRAM = `${DATASOURCE_DESCRIPTION_PROGRAM}
+import contextlib
+class Discard:
+    def write(self, value): return len(value)
+    def flush(self): pass
+try:
+    payload = json.load(sys.stdin)
+    with contextlib.redirect_stdout(Discard()), contextlib.redirect_stderr(Discard()):
+        current = project_description(md.describe(payload["name"]))
+        if current["definition"] != payload["definition"]:
+            result = {"error": "context-changed"}
+        elif md.remove(payload["name"]):
+            result = {"name": payload["name"]}
+        else:
+            result = {"error": "datasource-not-removable"}
+except Exception:
+    result = {"error": "datasource-remove-failed"}
+print(json.dumps(result))`;
+export const MARIVO_DATASOURCE_INVENTORY_PROGRAM = `${DATASOURCE_DESCRIPTION_PROGRAM}
 print(json.dumps({
-    "datasources": [{
-        "name": description.name,
-        "refs": list(description.env_refs.values()),
-    } for description in (md.describe(item.name) for item in md.list())],
+    "datasources": [project_description(md.describe(item.name)) for item in md.list()],
 }, sort_keys=True))
-`.trim();
-export const MARIVO_DATASOURCE_TEST_PROGRAM = String.raw `
+`;
+export const MARIVO_DATASOURCE_TEST_PROGRAM = `${RESOLVER_PROGRAM}\n${String.raw `
 import contextlib
 import io
 import json
@@ -34,17 +51,15 @@ import sys
 import marivo
 import marivo.datasource as md
 
+payload = json.load(sys.stdin)
+resolver = SnapshotResolver(payload)
+secret_values = list(payload["values"].values())
 captured_stdout = io.StringIO()
 captured_stderr = io.StringIO()
 try:
     with contextlib.redirect_stdout(captured_stdout), contextlib.redirect_stderr(captured_stderr):
-        description = md.describe(sys.argv[1])
-        secret_values = [
-            value
-            for ref in description.env_refs.values()
-            if (value := os.environ.get(ref))
-        ]
-        result = md.test(sys.argv[1])
+        with md.credential_scope(resolver=resolver):
+            result = md.test(sys.argv[1])
 except Exception as exc:
     print(json.dumps({"kind": "datasource-test-failed", "exception_type": type(exc).__name__}), file=sys.stderr)
     raise SystemExit(70)
@@ -77,4 +92,4 @@ print(json.dumps(redact({
     "failure": failure,
     "repair": repair,
 }), sort_keys=True))
-`.trim();
+`.trim()}`;

package/lib/datasource/bridge.js

@@ -1,7 +1,9 @@
 import { isCredentialRefName } from '@deepseek-ai/dsh-credentials';
 import { MarivoEnvironmentError } from "../environment/errors.js";
 import { resolveMarivoBridgeSource } from "../environment/source.js";
-import { MARIVO_DATASOURCE_DESCRIBE_PROGRAM, MARIVO_DATASOURCE_INVENTORY_PROGRAM, MARIVO_DATASOURCE_TEST_PROGRAM, } from "./bridge-programs.js";
+import { DATASOURCE_AUTHORING_PROGRAM, datasourceAuthoringSchema, } from "./authoring.js";
+import { MARIVO_DATASOURCE_DESCRIBE_PROGRAM, MARIVO_DATASOURCE_INVENTORY_PROGRAM, MARIVO_DATASOURCE_REMOVE_PROGRAM, MARIVO_DATASOURCE_TEST_PROGRAM, } from "./bridge-programs.js";
+import { marivoCredentialStorageRef } from "./shell-env.js";
 const DATASOURCE_LIMITS = Object.freeze({
     timeoutMs: 30_000,
     stdoutMaxBytes: 262_144,
@@ -24,6 +26,16 @@ function string(value) {
 function nullableString(value) {
     return value === null || typeof value === 'string';
 }
+function jsonValue(value) {
+    if (value === null || typeof value === 'string' || typeof value === 'boolean')
+        return true;
+    if (typeof value === 'number')
+        return Number.isFinite(value);
+    if (Array.isArray(value))
+        return value.every(jsonValue);
+    const fields = object(value);
+    return fields !== undefined && Object.values(fields).every(jsonValue);
+}
 function parseJsonObject(stdout, phase) {
     try {
         const parsed = JSON.parse(stdout.toString('utf8'));
@@ -41,15 +53,24 @@ function parseDescription(value, phase) {
     if (source === undefined) {
         throw new MarivoEnvironmentError('subprocess-output-invalid', `Marivo datasource ${phase} returned invalid fields`, { phase });
     }
-    exactKeys(source, ['name', 'refs'], phase);
+    exactKeys(source, ['name', 'backend', 'properties', 'refs', 'fields', 'definition'], phase);
     const name = string(source.name);
-    if (name === undefined || !Array.isArray(source.refs)) {
+    const backend = string(source.backend);
+    const properties = object(source.properties);
+    if (name === undefined ||
+        name.length > 256 ||
+        backend === undefined ||
+        backend.length > 256 ||
+        properties === undefined ||
+        !jsonValue(properties) ||
+        !Array.isArray(source.refs) ||
+        source.refs.length > 128) {
         throw new MarivoEnvironmentError('subprocess-output-invalid', `Marivo datasource ${phase} returned invalid fields`, { phase });
     }
     const refs = [];
     const seen = new Set();
     for (const ref of source.refs) {
-        if (typeof ref !== 'string' || !isCredentialRefName(ref)) {
+        if (typeof ref !== 'string' || ref.length > 256 || !isCredentialRefName(ref)) {
             throw new MarivoEnvironmentError('subprocess-output-invalid', `Marivo datasource ${phase} returned an invalid credential reference`, { phase });
         }
         if (!seen.has(ref)) {
@@ -57,7 +78,21 @@ function parseDescription(value, phase) {
             refs.push(ref);
         }
     }
-    return { name, refs };
+    const fields = object(source.fields);
+    if (!fields ||
+        typeof source.definition !== 'string' ||
+        !/^[a-f0-9]{64}$/.test(source.definition) ||
+        Object.values(fields).some((ref) => typeof ref !== 'string' || !refs.includes(ref)) ||
+        refs.some((ref) => !Object.values(fields).includes(ref)))
+        throw new Error('Invalid datasource definition projection');
+    return {
+        name,
+        backend,
+        properties: properties,
+        refs,
+        fields: fields,
+        definition: source.definition,
+    };
 }
 function parseInventory(stdout) {
     const value = parseJsonObject(stdout, 'inventory');
@@ -87,7 +122,9 @@ function parseRepair(value) {
         throw new TypeError('repair must be an object');
     exactKeys(source, ['kind', 'help_target', 'action', 'snippet', 'candidates', 'preserves_evidence'], 'test');
     if (string(source.kind) === undefined ||
-        string(source.help_target) === undefined ||
+        object(source.help_target) === undefined ||
+        string(object(source.help_target)?.surface) === undefined ||
+        !nullableString(object(source.help_target)?.canonical_id) ||
         typeof source.action !== 'string' ||
         !nullableString(source.snippet) ||
         !Array.isArray(source.candidates) ||
@@ -160,6 +197,81 @@ export class MarivoDatasourceBridge {
         this.#runner = runner;
         this.binding = runner.binding;
     }
+    async authoring(signal) {
+        const result = await this.#runner.runChecked({
+            program: DATASOURCE_AUTHORING_PROGRAM,
+            stdin: JSON.stringify({ action: 'schema' }),
+            limits: DATASOURCE_LIMITS,
+            signal,
+        });
+        this.#assertSuccess(result, 'inventory');
+        return datasourceAuthoringSchema.parse({
+            ...parseJsonObject(result.stdout, 'inventory'),
+            fingerprint: this.binding.fingerprint,
+        });
+    }
+    async configuration(name, signal) {
+        const result = await this.#runner.runChecked({
+            program: DATASOURCE_AUTHORING_PROGRAM,
+            stdin: JSON.stringify({ action: 'read', name }),
+            limits: DATASOURCE_LIMITS,
+            signal,
+        });
+        this.#assertSuccess(result, 'inventory');
+        const value = parseJsonObject(result.stdout, 'inventory');
+        if (value.name !== name ||
+            typeof value.backend !== 'string' ||
+            typeof value.version !== 'string' ||
+            !object(value.fields) ||
+            !jsonValue(value.fields))
+            throw new Error('Datasource configuration cannot be read completely');
+        return value;
+    }
+    async update(input, signal) {
+        return this.#write(input, 'update', signal);
+    }
+    async create(input, signal) {
+        return this.#write(input, 'create', signal);
+    }
+    async #write(input, action, signal) {
+        const refs = Object.entries(input.fields)
+            .filter(([key]) => key.endsWith('_env'))
+            .flatMap(([, value]) => typeof value === 'string'
+            ? [value]
+            : value && typeof value === 'object' && !Array.isArray(value)
+                ? Object.values(value)
+                : []);
+        for (const ref of refs) {
+            if (typeof ref !== 'string')
+                return { error: 'datasource-credential-ref-invalid' };
+            try {
+                marivoCredentialStorageRef(ref);
+            }
+            catch (error) {
+                if (error instanceof MarivoEnvironmentError &&
+                    error.code === 'datasource-credential-ref-invalid')
+                    return { error: 'datasource-credential-ref-invalid' };
+                throw error;
+            }
+        }
+        const result = await this.#runner.runChecked({
+            program: DATASOURCE_AUTHORING_PROGRAM,
+            stdin: JSON.stringify({ action, ...input, refs }),
+            limits: DATASOURCE_LIMITS,
+            signal,
+        });
+        this.#assertSuccess(result, 'inventory');
+        const value = parseJsonObject(result.stdout, 'inventory');
+        if (value.error === 'datasource-already-exists' ||
+            value.error === 'datasource-definition-invalid' ||
+            value.error === 'datasource-config-changed' ||
+            value.error === 'datasource-identity-fixed' ||
+            value.error === 'context-changed')
+            return { error: value.error };
+        if (typeof value.name !== 'string')
+            throw new Error('Invalid datasource creation result');
+        return { name: value.name };
+    }
     async describe(name, signal) {
         const result = await this.#runner.runChecked({
             program: MARIVO_DATASOURCE_DESCRIBE_PROGRAM,
@@ -170,6 +282,23 @@ export class MarivoDatasourceBridge {
         this.#assertSuccess(result, 'describe');
         return parseDescription(parseJsonObject(result.stdout, 'describe'), 'describe');
     }
+    async remove(description, signal) {
+        const result = await this.#runner.runChecked({
+            program: MARIVO_DATASOURCE_REMOVE_PROGRAM,
+            stdin: JSON.stringify({ name: description.name, definition: description.definition }),
+            limits: DATASOURCE_LIMITS,
+            signal,
+        });
+        this.#assertSuccess(result, 'inventory');
+        const value = parseJsonObject(result.stdout, 'inventory');
+        if (value.error === 'context-changed' ||
+            value.error === 'datasource-not-removable' ||
+            value.error === 'datasource-remove-failed')
+            return { error: value.error };
+        if (value.name !== description.name)
+            throw new Error('Invalid datasource removal result');
+        return { name: description.name };
+    }
     async inventory(signal) {
         const result = await this.#runner.runChecked({
             program: MARIVO_DATASOURCE_INVENTORY_PROGRAM,
@@ -179,16 +308,22 @@ export class MarivoDatasourceBridge {
         this.#assertSuccess(result, 'inventory');
         return parseInventory(result.stdout);
     }
-    async test(name, environmentOverlay, signal) {
+    async test(description, values, signal) {
+        const { name } = description;
         const result = await this.#runner.runChecked({
             program: MARIVO_DATASOURCE_TEST_PROGRAM,
             args: [name],
-            environmentOverlay,
+            stdin: JSON.stringify({
+                project_root: this.binding.projectRoot,
+                grants: { [name]: description },
+                values,
+            }),
+            secretValues: Object.values(values),
             limits: DATASOURCE_LIMITS,
             signal,
         });
         this.#assertSuccess(result, 'test');
-        return parseTest(result.stdout, Object.values(environmentOverlay).filter((value) => Boolean(value)));
+        return parseTest(result.stdout, Object.values(values));
     }
     #assertSuccess(result, phase) {
         if (result.exitCode === 0)

package/lib/datasource/changes-contract.js

@@ -0,0 +1,41 @@
+import { z } from 'zod';
+export const CREDENTIAL_CHANGES_SERVICE = 'dshDataAnalysisCredentials';
+const owner = '@chengxianglibra/dsh-data-analysis';
+const sessionId = z.string().min(1).max(256);
+export const credentialRevisionSchema = z
+    .object({ generation: z.string().uuid(), cursor: z.string().min(1).max(256) })
+    .strict();
+/** Plugin-owned strict boundary shared by both faces; no Host registry is duplicated. */
+const descriptor = {
+    id: `${owner}#${CREDENTIAL_CHANGES_SERVICE}/changes`,
+    service: CREDENTIAL_CHANGES_SERVICE,
+    namespace: CREDENTIAL_CHANGES_SERVICE,
+    method: 'changes',
+    mode: 'stream',
+    invocation: { kind: 'direct' },
+    parameters: [
+        {
+            name: 'sessionId',
+            wire: 'sessionId',
+            source: 'json',
+            codec: { mode: 'strict', typeSymbol: `${owner}#CredentialSessionId`, schema: sessionId },
+        },
+    ],
+    cancellation: { parameter: 'signal' },
+    result: {
+        mode: 'strict',
+        typeSymbol: `${owner}#CredentialRevision`,
+        schema: credentialRevisionSchema,
+    },
+};
+export const credentialChangesHost = {
+    package: owner,
+    face: 'host',
+    schemas: [],
+    model: { services: [], events: [], objects: [] },
+    invocations: [descriptor],
+};
+export const credentialChangesRemote = {
+    package: owner,
+    descriptors: [descriptor],
+};

package/lib/datasource/changes.js

@@ -0,0 +1,49 @@
+import { setTimeout as delay } from 'node:timers/promises';
+import { TypertRemoteService } from '@deepseek-ai/dsh-typert-protocol';
+import { PendingTasks } from "../lifecycle.js";
+import { CREDENTIAL_CHANGES_SERVICE } from "./changes-contract.js";
+import { CredentialServiceError } from "./service.js";
+/** Reuses the Host's logical stream carrier; credentials and waiting calls keep their owner. */
+export class CredentialChangesService extends TypertRemoteService {
+    credentials;
+    lifetime = new AbortController();
+    tasks = new PendingTasks();
+    closing;
+    constructor(ctx, credentials) {
+        super(ctx, CREDENTIAL_CHANGES_SERVICE);
+        this.credentials = credentials;
+    }
+    async *changes(sessionId, caller) {
+        const signal = AbortSignal.any([caller, this.lifetime.signal]);
+        let cursor;
+        while (!signal.aborted) {
+            const snapshot = await this.tasks.track(this.snapshot(sessionId, cursor, signal));
+            signal.throwIfAborted();
+            if (snapshot.cursor !== cursor) {
+                cursor = snapshot.cursor;
+                yield { generation: snapshot.generation, cursor };
+            }
+        }
+    }
+    async snapshot(sessionId, cursor, signal) {
+        let attempt = 0;
+        for (;;) {
+            signal.throwIfAborted();
+            try {
+                return await this.credentials.waitWatch(sessionId, cursor, signal);
+            }
+            catch (error) {
+                signal.throwIfAborted();
+                if (!(error instanceof CredentialServiceError) ||
+                    error.code !== 'credential-state-unavailable')
+                    throw new Error('credential-notification-unavailable');
+                await delay([1000, 2000, 5000][Math.min(attempt++, 2)], undefined, { signal });
+            }
+        }
+    }
+    close() {
+        this.lifetime.abort();
+        this.closing ??= this.tasks.drain();
+        return this.closing;
+    }
+}

package/lib/datasource/configure.js

@@ -0,0 +1,39 @@
+import { defineTool } from '@deepseek-ai/dsh-tools';
+import { registerMarivoTool } from "../tool-lifecycle.js";
+import { resolveMarivoDatasourceBridge } from "./bridge.js";
+export const MARIVO_DATASOURCE_CONFIGURE_TOOL_NAME = 'marivo_datasource_configure';
+export function createMarivoDatasourceConfigureTool(source, service) {
+    return defineTool({
+        name: MARIVO_DATASOURCE_CONFIGURE_TOOL_NAME,
+        description: 'Ask the user to create/select or edit a datasource in the owning Web session right tab. Waits until the user saves and tests successfully, cancels, or hands off a failure. Never pass credentials or configuration values. After success, rediscover the datasource and verify the requested table before analysis.',
+        parameters: {
+            mode: {
+                type: 'string',
+                required: true,
+                description: 'create (also permits choosing an existing datasource) or edit (fixed name and engine).',
+            },
+            name: { type: 'string', description: 'Existing datasource name, required only for edit.' },
+            reason: {
+                type: 'string',
+                required: true,
+                description: 'Brief reason for configuration, at most 1000 characters. No secrets.',
+            },
+        },
+        output: {
+            schema: { type: 'json' },
+            render: (_args, value) => [{ type: 'text', text: JSON.stringify(value) }],
+        },
+        async execute(args, exec) {
+            if (args.mode !== 'create' && args.mode !== 'edit')
+                throw new Error('Invalid configuration mode');
+            return JSON.parse(JSON.stringify(await service.track(service.configure(exec, () => resolveMarivoDatasourceBridge(source), {
+                mode: args.mode,
+                name: args.name,
+                reason: args.reason,
+            }))));
+        },
+    });
+}
+export function registerMarivoDatasourceConfigureTool(ctx, source, service) {
+    return registerMarivoTool(ctx, createMarivoDatasourceConfigureTool(source, service));
+}

package/lib/datasource/defaults.js

@@ -0,0 +1,25 @@
+import { z } from 'zod';
+import { CredentialServiceError } from "./service.js";
+/** Validate against this Workspace's live Runtime; never include config values in errors. */
+export function withDatasourceDefaults(schema, configured) {
+    if (configured === undefined)
+        return schema;
+    const parsed = z.record(z.string(), z.record(z.string(), z.json())).safeParse(configured);
+    if (!parsed.success)
+        throw new CredentialServiceError('datasource-defaults-invalid');
+    for (const [backend, values] of Object.entries(parsed.data)) {
+        const definition = schema.backends.find((item) => item.name === backend);
+        if (!definition)
+            throw new CredentialServiceError('datasource-defaults-backend-invalid');
+        for (const [name, value] of Object.entries(values)) {
+            const field = definition.fields.find((item) => item.name === name);
+            if (name.endsWith('_env'))
+                throw new CredentialServiceError('datasource-defaults-credential-forbidden');
+            if (!field)
+                throw new CredentialServiceError('datasource-defaults-field-invalid');
+            if (field.type !== 'json' && typeof value !== field.type)
+                throw new CredentialServiceError('datasource-defaults-type-invalid');
+        }
+    }
+    return { ...schema, creationDefaults: parsed.data };
+}

package/lib/datasource/index.js

@@ -1,4 +1,6 @@
-export { createMarivoDatasourceAccessTool, MARIVO_DATASOURCE_ACCESS_TOOL_NAME, registerMarivoDatasourceAccessTool, } from "./access.js";
 export { MarivoDatasourceBridge, resolveMarivoDatasourceBridge, resolveMarivoDatasourceInventoryBridge, } from "./bridge.js";
-export { assertMarivoCredentialReferences, DEFAULT_MARIVO_CREDENTIAL_LEASE_MAX_USES, DEFAULT_MARIVO_CREDENTIAL_LEASE_TTL_MS, MARIVO_CREDENTIAL_LEASE_PREFIX, MARIVO_CREDENTIAL_STORAGE_PREFIX, MarivoShellCredentialLeases, marivoCredentialStorageRef, } from "./shell-env.js";
+export { createMarivoDatasourceConfigureTool, MARIVO_DATASOURCE_CONFIGURE_TOOL_NAME, registerMarivoDatasourceConfigureTool, } from "./configure.js";
+export { MarivoPythonExecutionError, registerMarivoPythonTool } from "./python.js";
+export { MarivoCredentialService } from "./service.js";
+export { assertMarivoCredentialReferences, MARIVO_CREDENTIAL_STORAGE_PREFIX, marivoCredentialStorageRef, } from "./shell-env.js";
 export { createMarivoDatasourceTestTool, MARIVO_DATASOURCE_TEST_TOOL_NAME, registerMarivoDatasourceTestTool, } from "./test.js";

package/lib/datasource/python-options.js

@@ -0,0 +1,21 @@
+export const DEFAULT_PYTHON_TIMEOUT_MS = 120_000;
+export const DEFAULT_PYTHON_MAX_TIMEOUT_MS = 600_000;
+const MAX_TIMER_DELAY_MS = 2_147_483_647;
+/** Do not echo rejected inputs: tool arguments and configuration are not trusted diagnostics. */
+export function pythonTimeout(value, name) {
+    if (typeof value !== 'number' ||
+        !Number.isInteger(value) ||
+        value <= 0 ||
+        value > MAX_TIMER_DELAY_MS)
+        throw new Error(`${name} must be a positive integer no greater than ${MAX_TIMER_DELAY_MS}`);
+    return value;
+}
+export function resolvePythonOptions(options) {
+    const pythonTimeoutMs = pythonTimeout(options.pythonTimeoutMs === undefined ? DEFAULT_PYTHON_TIMEOUT_MS : options.pythonTimeoutMs, 'pythonTimeoutMs');
+    const pythonMaxTimeoutMs = pythonTimeout(options.pythonMaxTimeoutMs === undefined
+        ? DEFAULT_PYTHON_MAX_TIMEOUT_MS
+        : options.pythonMaxTimeoutMs, 'pythonMaxTimeoutMs');
+    if (pythonTimeoutMs > pythonMaxTimeoutMs)
+        throw new Error('pythonTimeoutMs must not exceed pythonMaxTimeoutMs');
+    return { pythonTimeoutMs, pythonMaxTimeoutMs };
+}