@reasonlayer/sdk 0.0.1-rc.3

package/dist/cli/args.js

@@ -0,0 +1,71 @@
+const BOOLEAN_FLAGS = new Set([
+    "bootstrap",
+    "disable",
+    "enable",
+    "help",
+    "json",
+    "local",
+    "no-wait",
+    "once",
+    "value-stdin",
+    "version",
+    "watch",
+    "wait",
+]);
+export function parseCliArgs(argv) {
+    let command;
+    const positionals = [];
+    const flags = {};
+    for (let i = 0; i < argv.length; i += 1) {
+        const arg = argv[i];
+        if (!command && !arg.startsWith("-")) {
+            command = arg;
+            continue;
+        }
+        if (arg === "--") {
+            positionals.push(...argv.slice(i + 1));
+            break;
+        }
+        if (!arg.startsWith("--")) {
+            positionals.push(arg);
+            continue;
+        }
+        const raw = arg.slice(2);
+        const eq = raw.indexOf("=");
+        if (eq !== -1) {
+            flags[raw.slice(0, eq)] = raw.slice(eq + 1);
+            continue;
+        }
+        if (BOOLEAN_FLAGS.has(raw)) {
+            flags[raw] = true;
+            continue;
+        }
+        const next = argv[i + 1];
+        if (next !== undefined && !next.startsWith("--")) {
+            flags[raw] = next;
+            i += 1;
+        }
+        else {
+            flags[raw] = true;
+        }
+    }
+    return { command, positionals, flags };
+}
+export function hasFlag(parsed, name) {
+    return parsed.flags[name] === true;
+}
+export function stringFlag(parsed, name) {
+    const value = parsed.flags[name];
+    if (typeof value === "string")
+        return value;
+    return undefined;
+}
+export function numberFlag(parsed, name) {
+    const value = stringFlag(parsed, name);
+    if (value === undefined)
+        return undefined;
+    const n = Number(value);
+    if (!Number.isFinite(n))
+        throw new Error(`--${name} must be a number`);
+    return n;
+}

package/dist/cli/config.d.ts

@@ -0,0 +1,38 @@
+export declare const TOKEN_ONBOARDING_HINT: string;
+/** What operations consume: a deployment URL plus a bearer token. */
+export interface RlConfig {
+    convexUrl: string;
+    token: string;
+}
+/** Non-secret account metadata persisted for user-facing diagnostics. */
+export interface RlAccount {
+    email?: string;
+    orgId?: string;
+}
+/**
+ * Global (per-user) config lives in `$HOME/.rl/config.json`. `RL_HOME`
+ * overrides the directory — production override and test isolation seam.
+ */
+export declare function globalConfigPath(): string;
+export declare function resolvedConvexUrl(): string;
+export declare function resolvedTargetLabel(): "production" | "dev override";
+export declare function loadConfig(options?: {
+    optional?: false;
+}): Promise<RlConfig>;
+export declare function loadConfig(options: {
+    optional: true;
+}): Promise<RlConfig | undefined>;
+export interface SavedLogin {
+    configPath: string;
+}
+/**
+ * Persist a successful login: token to the OS keychain, non-secret account
+ * metadata to the global config file. There is deliberately no plaintext-file
+ * fallback (spec §11) — if the keychain is unavailable we fail with guidance to
+ * use RL_TOKEN with a scoped `rl_pt_` token, which is the headless/CI path.
+ */
+export declare function saveLogin(convexUrl: string, token: string, account?: RlAccount): Promise<SavedLogin>;
+/** Remove the stored token for the currently resolved deployment. */
+export declare function clearLogin(convexUrl?: string): Promise<{
+    convexUrl: string;
+}>;

package/dist/cli/config.js

@@ -0,0 +1,94 @@
+import { mkdir, writeFile } from "node:fs/promises";
+import { homedir } from "node:os";
+import { dirname, join, resolve } from "node:path";
+import { PRODUCTION_CONVEX_URL } from "@reasonlayer/protocol";
+import * as keychain from "./keychain.js";
+import { KeychainAccessError, KeychainUnavailableError } from "./keychain.js";
+export const TOKEN_ONBOARDING_HINT = "Create a platform token in the Reasonlayer console under Capabilities > Tokens, then " +
+    'run "rl login --token <token>". Inside the repo, run "pnpm rl login --token <token>" ' +
+    "to log in to the local dev deployment.";
+/**
+ * Global (per-user) config lives in `$HOME/.rl/config.json`. `RL_HOME`
+ * overrides the directory — production override and test isolation seam.
+ */
+export function globalConfigPath() {
+    const home = process.env["RL_HOME"];
+    return home ? join(resolve(home), "config.json") : join(homedir(), ".rl", "config.json");
+}
+async function writeConfigFile(path, file) {
+    await mkdir(dirname(path), { recursive: true, mode: 0o700 });
+    await writeFile(path, `${JSON.stringify(file, null, 2)}\n`, { mode: 0o600 });
+}
+function isKeychainError(err) {
+    return err instanceof KeychainUnavailableError || err instanceof KeychainAccessError;
+}
+export function resolvedConvexUrl() {
+    return process.env["RL_CONVEX_URL"] ?? PRODUCTION_CONVEX_URL;
+}
+export function resolvedTargetLabel() {
+    return process.env["RL_CONVEX_URL"] === undefined ? "production" : "dev override";
+}
+export async function loadConfig(options = {}) {
+    const convexUrl = resolvedConvexUrl();
+    const envToken = process.env["RL_TOKEN"];
+    if (envToken !== undefined)
+        return { convexUrl, token: envToken };
+    let token;
+    let keychainError;
+    try {
+        token = (await keychain.getToken(convexUrl)) ?? undefined;
+    }
+    catch (err) {
+        if (err instanceof KeychainAccessError)
+            keychainError = err;
+        else if (!(err instanceof KeychainUnavailableError))
+            throw err;
+    }
+    if (token !== undefined)
+        return { convexUrl, token };
+    if (options.optional)
+        return undefined;
+    // A keychain that holds the token but refused to read it is a distinct
+    // failure from "no login" — surface it rather than a misleading prompt.
+    if (keychainError) {
+        throw new Error(`${keychainError.message}. Your keychain may be locked or the access prompt was denied — ` +
+            "re-run and approve it, or set RL_TOKEN with a scoped token.");
+    }
+    throw notLoggedIn();
+}
+function notLoggedIn() {
+    return new Error(`not logged in: ${TOKEN_ONBOARDING_HINT}`);
+}
+/**
+ * Persist a successful login: token to the OS keychain, non-secret account
+ * metadata to the global config file. There is deliberately no plaintext-file
+ * fallback (spec §11) — if the keychain is unavailable we fail with guidance to
+ * use RL_TOKEN with a scoped `rl_pt_` token, which is the headless/CI path.
+ */
+export async function saveLogin(convexUrl, token, account = {}) {
+    try {
+        await keychain.setToken(convexUrl, token);
+    }
+    catch (err) {
+        if (isKeychainError(err)) {
+            throw new Error(`${err.message}. Unlock your keychain and retry, or for headless/CI use ` +
+                "RL_TOKEN with a scoped token instead of an interactive login.");
+        }
+        throw err;
+    }
+    const path = globalConfigPath();
+    const hasAccount = account.email !== undefined || account.orgId !== undefined;
+    await writeConfigFile(path, hasAccount ? { account } : {});
+    return { configPath: path };
+}
+/** Remove the stored token for the currently resolved deployment. */
+export async function clearLogin(convexUrl = resolvedConvexUrl()) {
+    try {
+        await keychain.deleteToken(convexUrl);
+    }
+    catch (err) {
+        if (!isKeychainError(err))
+            throw err;
+    }
+    return { convexUrl };
+}

package/dist/cli/convex.d.ts

@@ -0,0 +1,9 @@
+import type { RlConfig } from "./config.js";
+export declare class RlConvexClient {
+    readonly config: RlConfig;
+    private readonly client;
+    constructor(config: RlConfig);
+    query<T>(name: string, args: Record<string, unknown>): Promise<T>;
+    mutation<T>(name: string, args: Record<string, unknown>): Promise<T>;
+    action<T>(name: string, args: Record<string, unknown>): Promise<T>;
+}

package/dist/cli/convex.js

@@ -0,0 +1,25 @@
+import { ConvexHttpClient } from "convex/browser";
+import { makeFunctionReference } from "convex/server";
+function fn(kind, name) {
+    return makeFunctionReference(name);
+}
+export class RlConvexClient {
+    config;
+    client;
+    constructor(config) {
+        this.config = config;
+        this.client = new ConvexHttpClient(config.convexUrl, {
+            logger: false,
+            skipConvexDeploymentUrlCheck: true,
+        });
+    }
+    query(name, args) {
+        return this.client.query(fn("query", name), args);
+    }
+    mutation(name, args) {
+        return this.client.mutation(fn("mutation", name), args, { skipQueue: true });
+    }
+    action(name, args) {
+        return this.client.action(fn("action", name), args);
+    }
+}

package/dist/cli/format.d.ts

@@ -0,0 +1,11 @@
+export declare function serializeCliValue(value: unknown, key?: string): unknown;
+export declare function jsonText(value: unknown): string;
+export declare function parseVariableValue(raw: string): unknown;
+export declare function formatVariableList(value: unknown): string;
+export declare function formatCompileErrors(result: {
+    errors: {
+        stepId?: string;
+        message: string;
+    }[];
+}): string;
+export declare function formatInspect(value: unknown): string;

package/dist/cli/format.js

@@ -0,0 +1,140 @@
+const OPAQUE_VALUE_KEYS = new Set([
+    "buildInfo",
+    "content",
+    "data",
+    "decision",
+    "input",
+    "inputSchema",
+    "ir",
+    "output",
+    "outputSchema",
+    "schema",
+    "schemaJson",
+    "settings",
+    "variables",
+    "value",
+    "defaultJson",
+]);
+const TIMESTAMP_KEYS = new Set([
+    "at",
+    "checkedAt",
+    "connectStartedAt",
+    "connectedAt",
+    "createdAt",
+    "deadlineAt",
+    "deletedAt",
+    "draftUpdatedAt",
+    "endedAt",
+    "expiresAt",
+    "finishedAt",
+    "lastCheckedAt",
+    "lastFiredAt",
+    "lastHealthyAt",
+    "lastHeartbeatAt",
+    "lastRefreshedAt",
+    "lastSeenAt",
+    "lastUsedAt",
+    "leaseExpiresAt",
+    "loginCompletedAt",
+    "loginRequestedAt",
+    "nextFireAt",
+    "nextRunAt",
+    "resolvedAt",
+    "revokedAt",
+    "scheduledFor",
+    "startedAt",
+    "ts",
+    "updatedAt",
+    "workosUpdatedAt",
+]);
+function isTimestampKey(key) {
+    return TIMESTAMP_KEYS.has(key);
+}
+function isoTimestamp(value) {
+    if (!Number.isFinite(value))
+        return value;
+    const date = new Date(value);
+    return Number.isNaN(date.getTime()) ? value : date.toISOString();
+}
+export function serializeCliValue(value, key) {
+    if (key !== undefined && OPAQUE_VALUE_KEYS.has(key))
+        return value;
+    if (typeof value === "number" && key !== undefined && isTimestampKey(key)) {
+        return isoTimestamp(value);
+    }
+    if (Array.isArray(value)) {
+        return value.map((item) => serializeCliValue(item));
+    }
+    if (value !== null && typeof value === "object") {
+        return Object.fromEntries(Object.entries(value).map(([entryKey, entryValue]) => [
+            entryKey,
+            serializeCliValue(entryValue, entryKey),
+        ]));
+    }
+    return value;
+}
+export function jsonText(value) {
+    return `${JSON.stringify(serializeCliValue(value), null, 2)}\n`;
+}
+export function parseVariableValue(raw) {
+    try {
+        return JSON.parse(raw);
+    }
+    catch {
+        return raw;
+    }
+}
+function inlineJson(value) {
+    return JSON.stringify(value) ?? String(value);
+}
+export function formatVariableList(value) {
+    if (!Array.isArray(value) || value.length === 0)
+        return "No variables declared.\n";
+    const lines = value.map((item) => {
+        const variable = item;
+        const hasOverride = Object.hasOwn(variable, "value");
+        const current = hasOverride ? variable.value : variable.defaultJson;
+        return `${variable.name}: ${inlineJson(current)}${hasOverride ? "" : " (default)"}`;
+    });
+    return `${lines.join("\n")}\n`;
+}
+export function formatCompileErrors(result) {
+    return result.errors
+        .map((error) => `${error.stepId ? `${error.stepId}: ` : ""}${error.message}`)
+        .join("\n");
+}
+export function formatInspect(value) {
+    const inspected = value;
+    if (!inspected.run)
+        return jsonText(value);
+    const lines = [
+        `Run ${inspected.run.runId}`,
+        `Workflow: ${inspected.run.workflowId}`,
+        `Status: ${inspected.run.status}`,
+    ];
+    if (inspected.run.error)
+        lines.push(`Error: ${inspected.run.error}`);
+    if (inspected.run.output !== undefined) {
+        lines.push(`Output: ${JSON.stringify(inspected.run.output)}`);
+    }
+    if (inspected.steps && inspected.steps.length > 0) {
+        lines.push("Steps:");
+        for (const step of inspected.steps) {
+            const key = step.invocationKey ? ` key=${step.invocationKey}` : "";
+            const error = step.error ? ` error=${JSON.stringify(step.error)}` : "";
+            lines.push(`- ${step.stepId}${key} attempt=${step.attempt} status=${step.status}${error}`);
+        }
+    }
+    if (inspected.usage) {
+        const u = inspected.usage.totals;
+        lines.push(`Usage: input=${u.inputTokens} output=${u.outputTokens} cost=$${u.costUsd.toFixed(6)}`);
+    }
+    if (inspected.transcript && inspected.transcript.length > 0) {
+        lines.push("Transcript:");
+        for (const event of inspected.transcript) {
+            const key = event.invocationKey ? ` key=${event.invocationKey}` : "";
+            lines.push(`- ${event.stepId}${key} attempt=${event.attempt} seq=${event.seq} ${event.level} ${event.type} ${JSON.stringify(event.data)}`);
+        }
+    }
+    return `${lines.join("\n")}\n`;
+}

package/dist/cli/index.d.ts

@@ -0,0 +1 @@
+export declare function main(argv: readonly string[]): Promise<number>;