@treeship/sdk 0.1.0

package/dist/attest.d.ts

@@ -0,0 +1,7 @@
+import type { ActionParams, ApprovalParams, HandoffParams, DecisionParams, ActionResult, ApprovalResult } from "./types.js";
+export declare class AttestModule {
+    action(params: ActionParams): Promise<ActionResult>;
+    approval(params: ApprovalParams): Promise<ApprovalResult>;
+    handoff(params: HandoffParams): Promise<ActionResult>;
+    decision(params: DecisionParams): Promise<ActionResult>;
+}

package/dist/attest.js

@@ -0,0 +1,49 @@
+import { runTreeship } from "./exec.js";
+export class AttestModule {
+    async action(params) {
+        const args = ["attest", "action", "--actor", params.actor, "--action", params.action, "--format", "json"];
+        if (params.parentId)
+            args.push("--parent", params.parentId);
+        if (params.approvalNonce)
+            args.push("--approval-nonce", params.approvalNonce);
+        if (params.meta)
+            args.push("--meta", JSON.stringify(params.meta));
+        const result = await runTreeship(args);
+        return { artifactId: (result.id || result.artifact_id) };
+    }
+    async approval(params) {
+        const args = ["attest", "approval", "--approver", params.approver, "--description", params.description, "--format", "json"];
+        if (params.expiresIn)
+            args.push("--expires", params.expiresIn);
+        const result = await runTreeship(args);
+        return { artifactId: (result.id || result.artifact_id), nonce: result.nonce };
+    }
+    async handoff(params) {
+        const args = ["attest", "handoff", "--from", params.from, "--to", params.to, "--artifacts", params.artifacts.join(","), "--format", "json"];
+        if (params.approvals?.length)
+            args.push("--approvals", params.approvals.join(","));
+        if (params.obligations?.length)
+            args.push("--obligations", params.obligations.join(","));
+        const result = await runTreeship(args);
+        return { artifactId: (result.id || result.artifact_id) };
+    }
+    async decision(params) {
+        const args = ["attest", "decision", "--actor", params.actor, "--format", "json"];
+        if (params.model)
+            args.push("--model", params.model);
+        if (params.tokensIn)
+            args.push("--tokens-in", String(params.tokensIn));
+        if (params.tokensOut)
+            args.push("--tokens-out", String(params.tokensOut));
+        if (params.promptDigest)
+            args.push("--prompt-digest", params.promptDigest);
+        if (params.summary)
+            args.push("--summary", params.summary);
+        if (params.confidence)
+            args.push("--confidence", String(params.confidence));
+        if (params.parentId)
+            args.push("--parent", params.parentId);
+        const result = await runTreeship(args);
+        return { artifactId: (result.id || result.artifact_id) };
+    }
+}

package/dist/dock.d.ts

@@ -0,0 +1,10 @@
+import type { PushResult } from "./types.js";
+export declare class DockModule {
+    push(id: string): Promise<PushResult>;
+    pull(id: string): Promise<void>;
+    status(): Promise<{
+        docked: boolean;
+        endpoint?: string;
+        dockId?: string;
+    }>;
+}

package/dist/dock.js

@@ -0,0 +1,26 @@
+import { runTreeship } from "./exec.js";
+export class DockModule {
+    async push(id) {
+        const result = await runTreeship(["dock", "push", id, "--format", "json"]);
+        return {
+            hubUrl: (result.hub_url || result.url || ""),
+            rekorIndex: result.rekor_index,
+        };
+    }
+    async pull(id) {
+        await runTreeship(["dock", "pull", id]);
+    }
+    async status() {
+        try {
+            const result = await runTreeship(["dock", "status", "--format", "json"]);
+            return {
+                docked: result.status === "docked",
+                endpoint: result.endpoint,
+                dockId: result.dock_id,
+            };
+        }
+        catch {
+            return { docked: false };
+        }
+    }
+}

package/dist/exec.d.ts

@@ -0,0 +1 @@
+export declare function runTreeship(args: string[]): Promise<Record<string, unknown>>;

package/dist/exec.js

@@ -0,0 +1,17 @@
+import { execFile } from "node:child_process";
+import { promisify } from "node:util";
+import { TreeshipError } from "./types.js";
+const exec = promisify(execFile);
+export async function runTreeship(args) {
+    try {
+        const { stdout } = await exec("treeship", args, {
+            timeout: 10_000,
+            env: { ...process.env },
+        });
+        return JSON.parse(stdout);
+    }
+    catch (e) {
+        const msg = e instanceof Error ? e.message : String(e);
+        throw new TreeshipError(`treeship ${args.slice(0, 2).join(" ")} failed: ${msg}`, args);
+    }
+}

package/dist/index.d.ts

@@ -0,0 +1,7 @@
+import { Ship } from "./ship.js";
+export declare function ship(): Ship;
+export { Ship } from "./ship.js";
+export { AttestModule } from "./attest.js";
+export { VerifyModule } from "./verify.js";
+export { DockModule } from "./dock.js";
+export * from "./types.js";

package/dist/index.js

@@ -0,0 +1,9 @@
+import { Ship } from "./ship.js";
+export function ship() {
+    return new Ship();
+}
+export { Ship } from "./ship.js";
+export { AttestModule } from "./attest.js";
+export { VerifyModule } from "./verify.js";
+export { DockModule } from "./dock.js";
+export * from "./types.js";

package/dist/ship.d.ts

@@ -0,0 +1,8 @@
+import { AttestModule } from "./attest.js";
+import { VerifyModule } from "./verify.js";
+import { DockModule } from "./dock.js";
+export declare class Ship {
+    readonly attest: AttestModule;
+    readonly verify: VerifyModule;
+    readonly dock: DockModule;
+}

package/dist/ship.js

@@ -0,0 +1,8 @@
+import { AttestModule } from "./attest.js";
+import { VerifyModule } from "./verify.js";
+import { DockModule } from "./dock.js";
+export class Ship {
+    attest = new AttestModule();
+    verify = new VerifyModule();
+    dock = new DockModule();
+}

package/dist/types.d.ts

@@ -0,0 +1,51 @@
+export interface ActionParams {
+    actor: string;
+    action: string;
+    parentId?: string;
+    approvalNonce?: string;
+    meta?: Record<string, unknown>;
+}
+export interface ApprovalParams {
+    approver: string;
+    description: string;
+    expiresIn?: string;
+    scope?: string;
+}
+export interface HandoffParams {
+    from: string;
+    to: string;
+    artifacts: string[];
+    approvals?: string[];
+    obligations?: string[];
+}
+export interface DecisionParams {
+    actor: string;
+    model?: string;
+    modelVersion?: string;
+    tokensIn?: number;
+    tokensOut?: number;
+    promptDigest?: string;
+    summary?: string;
+    confidence?: number;
+    parentId?: string;
+}
+export interface ActionResult {
+    artifactId: string;
+}
+export interface ApprovalResult {
+    artifactId: string;
+    nonce: string;
+}
+export interface VerifyResult {
+    outcome: "pass" | "fail" | "error";
+    chain: number;
+    target: string;
+}
+export interface PushResult {
+    hubUrl: string;
+    rekorIndex?: number;
+}
+export declare class TreeshipError extends Error {
+    readonly args: string[];
+    constructor(message: string, args: string[]);
+}

package/dist/types.js

@@ -0,0 +1,8 @@
+export class TreeshipError extends Error {
+    args;
+    constructor(message, args) {
+        super(message);
+        this.args = args;
+        this.name = "TreeshipError";
+    }
+}

package/dist/verify.d.ts

@@ -0,0 +1,4 @@
+import type { VerifyResult } from "./types.js";
+export declare class VerifyModule {
+    verify(id: string): Promise<VerifyResult>;
+}

package/dist/verify.js

@@ -0,0 +1,11 @@
+import { runTreeship } from "./exec.js";
+export class VerifyModule {
+    async verify(id) {
+        const result = await runTreeship(["verify", id, "--format", "json"]);
+        return {
+            outcome: result.outcome === "pass" ? "pass" : result.outcome === "error" ? "error" : "fail",
+            chain: (result.total || result.chain || 1),
+            target: id,
+        };
+    }
+}

package/package.json

@@ -0,0 +1,34 @@
+{
+  "name": "@treeship/sdk",
+  "version": "0.1.0",
+  "description": "TypeScript SDK for Treeship - portable trust receipts for agent workflows",
+  "license": "Apache-2.0",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/zerkerlabs/treeship",
+    "directory": "packages/sdk-ts"
+  },
+  "homepage": "https://treeship.dev",
+  "keywords": ["treeship", "attestation", "trust", "agents", "verification", "receipts"],
+  "type": "module",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "exports": {
+    ".": {
+      "import": "./dist/index.js",
+      "types": "./dist/index.d.ts"
+    }
+  },
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "build": "tsc",
+    "test": "vitest run"
+  },
+  "devDependencies": {
+    "@types/node": "^25.5.0",
+    "typescript": "^5.7.0",
+    "vitest": "^3.0.0"
+  }
+}