@intentic/sandbox-contract 1.125.1 → 1.132.0

package/dist/contracts/history.contract.d.ts

@@ -5,26 +5,24 @@ export declare const historyContract: {
             at: import("zod").ZodNumber;
             trigger: import("zod").ZodEnum<{
                 interval: "interval";
-                user: "user";
-                turn: "turn";
-                manual: "manual";
                 "pre-restore": "pre-restore";
                 restore: "restore";
+                turn: "turn";
+                user: "user";
             }>;
-            scopes: import("zod").ZodArray<import("zod").ZodString>;
+            label: import("zod").ZodOptional<import("zod").ZodString>;
         }, import("zod/v4/core").$strip>>;
     }, import("zod/v4/core").$strip>, Record<never, never>, Record<never, never>>;
     diff: import("@orpc/contract").ContractProcedureBuilderWithInputOutput<import("zod").ZodObject<{
         id: import("zod").ZodString;
-        base: import("zod").ZodOptional<import("zod").ZodString>;
     }, import("zod/v4/core").$strip>, import("zod").ZodObject<{
         changes: import("zod").ZodArray<import("zod").ZodObject<{
             scope: import("zod").ZodString;
             path: import("zod").ZodString;
             status: import("zod").ZodEnum<{
                 added: "added";
-                modified: "modified";
                 deleted: "deleted";
+                modified: "modified";
                 "type-changed": "type-changed";
             }>;
         }, import("zod/v4/core").$strip>>;
@@ -33,16 +31,12 @@ export declare const historyContract: {
         id: import("zod").ZodString;
         scope: import("zod").ZodString;
         path: import("zod").ZodString;
-        base: import("zod").ZodOptional<import("zod").ZodString>;
     }, import("zod/v4/core").$strip>, import("zod").ZodObject<{
         before: import("zod").ZodOptional<import("zod").ZodString>;
         after: import("zod").ZodOptional<import("zod").ZodString>;
         binary: import("zod").ZodOptional<import("zod").ZodBoolean>;
         truncated: import("zod").ZodOptional<import("zod").ZodBoolean>;
     }, import("zod/v4/core").$strip>, Record<never, never>, Record<never, never>>;
-    snapshot: import("@orpc/contract").ContractProcedureBuilderWithOutput<import("@orpc/contract").Schema<unknown, unknown>, import("zod").ZodObject<{
-        id: import("zod").ZodOptional<import("zod").ZodString>;
-    }, import("zod/v4/core").$strip>, Record<never, never>, Record<never, never>>;
     restore: import("@orpc/contract").ContractProcedureBuilderWithInputOutput<import("zod").ZodObject<{
         id: import("zod").ZodString;
     }, import("zod/v4/core").$strip>, import("zod").ZodObject<{

package/dist/contracts/history.contract.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"history.contract.d.ts","sourceRoot":"","sources":["../../src/contracts/history.contract.ts"],"names":[],"mappings":"AAcA,eAAO,MAAM,eAAe;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAM3B,CAAC"}
+{"version":3,"file":"history.contract.d.ts","sourceRoot":"","sources":["../../src/contracts/history.contract.ts"],"names":[],"mappings":"AAMA,eAAO,MAAM,eAAe;IACxB,IAAI;;;;;;;;;;;;;;IACJ,IAAI;;;;;;;;;;;;;;IACJ,QAAQ;;;;;;;;;;IACR,OAAO;;;;;CACV,CAAC"}

package/dist/contracts/history.contract.js

@@ -1,10 +1,9 @@
 import { oc } from "@orpc/contract";
-import { OkSchema, SnapshotDiffQuerySchema, SnapshotDiffSchema, SnapshotFileDiffQuerySchema, SnapshotFileDiffSchema, SnapshotIdSchema, SnapshotResultSchema, SnapshotsListSchema, } from "../schemas.js";
+import { FileDiffSchema, OkSchema, SnapshotDiffSchema, SnapshotFileDiffQuerySchema, SnapshotIdSchema, SnapshotsListSchema } from "../schemas.js";
 export const historyContract = {
     list: oc.route({ method: "GET", path: "/history/snapshots" }).output(SnapshotsListSchema),
-    diff: oc.route({ method: "GET", path: "/history/diff" }).input(SnapshotDiffQuerySchema).output(SnapshotDiffSchema),
-    fileDiff: oc.route({ method: "GET", path: "/history/file-diff" }).input(SnapshotFileDiffQuerySchema).output(SnapshotFileDiffSchema),
-    snapshot: oc.route({ method: "POST", path: "/history/snapshot" }).output(SnapshotResultSchema),
+    diff: oc.route({ method: "GET", path: "/history/diff" }).input(SnapshotIdSchema).output(SnapshotDiffSchema),
+    fileDiff: oc.route({ method: "GET", path: "/history/file-diff" }).input(SnapshotFileDiffQuerySchema).output(FileDiffSchema),
     restore: oc.route({ method: "POST", path: "/history/restore" }).input(SnapshotIdSchema).output(OkSchema),
 };
 //# sourceMappingURL=history.contract.js.map

package/dist/contracts/history.contract.js.map

@@ -1 +1 @@
-{"version":3,"file":"history.contract.js","sourceRoot":"","sources":["../../src/contracts/history.contract.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,EAAE,EAAE,MAAM,gBAAgB,CAAC;AACpC,OAAO,EACH,QAAQ,EACR,uBAAuB,EACvB,kBAAkB,EAClB,2BAA2B,EAC3B,sBAAsB,EACtB,gBAAgB,EAChB,oBAAoB,EACpB,mBAAmB,GACtB,MAAM,eAAe,CAAC;AAIvB,MAAM,CAAC,MAAM,eAAe,GAAG;IAC3B,IAAI,EAAE,EAAE,CAAC,KAAK,CAAC,EAAE,MAAM,EAAE,KAAK,EAAE,IAAI,EAAE,oBAAoB,EAAE,CAAC,CAAC,MAAM,CAAC,mBAAmB,CAAC;IACzF,IAAI,EAAE,EAAE,CAAC,KAAK,CAAC,EAAE,MAAM,EAAE,KAAK,EAAE,IAAI,EAAE,eAAe,EAAE,CAAC,CAAC,KAAK,CAAC,uBAAuB,CAAC,CAAC,MAAM,CAAC,kBAAkB,CAAC;IAClH,QAAQ,EAAE,EAAE,CAAC,KAAK,CAAC,EAAE,MAAM,EAAE,KAAK,EAAE,IAAI,EAAE,oBAAoB,EAAE,CAAC,CAAC,KAAK,CAAC,2BAA2B,CAAC,CAAC,MAAM,CAAC,sBAAsB,CAAC;IACnI,QAAQ,EAAE,EAAE,CAAC,KAAK,CAAC,EAAE,MAAM,EAAE,MAAM,EAAE,IAAI,EAAE,mBAAmB,EAAE,CAAC,CAAC,MAAM,CAAC,oBAAoB,CAAC;IAC9F,OAAO,EAAE,EAAE,CAAC,KAAK,CAAC,EAAE,MAAM,EAAE,MAAM,EAAE,IAAI,EAAE,kBAAkB,EAAE,CAAC,CAAC,KAAK,CAAC,gBAAgB,CAAC,CAAC,MAAM,CAAC,QAAQ,CAAC;CAC3G,CAAC"}
+{"version":3,"file":"history.contract.js","sourceRoot":"","sources":["../../src/contracts/history.contract.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,EAAE,EAAE,MAAM,gBAAgB,CAAC;AACpC,OAAO,EAAE,cAAc,EAAE,QAAQ,EAAE,kBAAkB,EAAE,2BAA2B,EAAE,gBAAgB,EAAE,mBAAmB,EAAE,MAAM,eAAe,CAAC;AAKjJ,MAAM,CAAC,MAAM,eAAe,GAAG;IAC3B,IAAI,EAAE,EAAE,CAAC,KAAK,CAAC,EAAE,MAAM,EAAE,KAAK,EAAE,IAAI,EAAE,oBAAoB,EAAE,CAAC,CAAC,MAAM,CAAC,mBAAmB,CAAC;IACzF,IAAI,EAAE,EAAE,CAAC,KAAK,CAAC,EAAE,MAAM,EAAE,KAAK,EAAE,IAAI,EAAE,eAAe,EAAE,CAAC,CAAC,KAAK,CAAC,gBAAgB,CAAC,CAAC,MAAM,CAAC,kBAAkB,CAAC;IAC3G,QAAQ,EAAE,EAAE,CAAC,KAAK,CAAC,EAAE,MAAM,EAAE,KAAK,EAAE,IAAI,EAAE,oBAAoB,EAAE,CAAC,CAAC,KAAK,CAAC,2BAA2B,CAAC,CAAC,MAAM,CAAC,cAAc,CAAC;IAC3H,OAAO,EAAE,EAAE,CAAC,KAAK,CAAC,EAAE,MAAM,EAAE,MAAM,EAAE,IAAI,EAAE,kBAAkB,EAAE,CAAC,CAAC,KAAK,CAAC,gBAAgB,CAAC,CAAC,MAAM,CAAC,QAAQ,CAAC;CAC3G,CAAC"}

package/dist/contracts/intentic.contract.d.ts

@@ -11,5 +11,12 @@ export declare const intenticContract: {
     apply: import("@orpc/contract").ContractProcedureBuilderWithOutput<import("@orpc/contract").Schema<unknown, unknown>, import("zod").ZodObject<{
         ok: import("zod").ZodLiteral<true>;
     }, import("zod/v4/core").$strip>, Record<never, never>, Record<never, never>>;
+    applyEvents: import("@orpc/contract").ContractProcedureBuilderWithOutput<import("@orpc/contract").Schema<unknown, unknown>, import("@orpc/contract").Schema<AsyncIteratorObject<{
+        [x: string]: unknown;
+        kind: string;
+    }, unknown, void>, import("@orpc/contract").AsyncIteratorClass<{
+        [x: string]: unknown;
+        kind: string;
+    }, unknown, void>>, Record<never, never>, Record<never, never>>;
 };
 //# sourceMappingURL=intentic.contract.d.ts.map

package/dist/contracts/intentic.contract.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"intentic.contract.d.ts","sourceRoot":"","sources":["../../src/contracts/intentic.contract.ts"],"names":[],"mappings":"AAMA,eAAO,MAAM,gBAAgB;;;;;;;;;;;;;CAK5B,CAAC"}
+{"version":3,"file":"intentic.contract.d.ts","sourceRoot":"","sources":["../../src/contracts/intentic.contract.ts"],"names":[],"mappings":"AAMA,eAAO,MAAM,gBAAgB;IACzB,GAAG;;;;;;;;;IAGH,KAAK;;;IAKL,WAAW;;;;;;;CACd,CAAC"}

package/dist/contracts/intentic.contract.js

@@ -4,5 +4,6 @@ import { IntenticRunSchema, OkSchema } from "../schemas.js";
 export const intenticContract = {
     run: oc.route({ method: "POST", path: "/intentic" }).input(IntenticRunSchema).output(eventIterator(IntenticLineSchema)),
     apply: oc.route({ method: "POST", path: "/intentic/apply" }).output(OkSchema),
+    applyEvents: oc.route({ method: "GET", path: "/intentic/apply/events" }).output(eventIterator(IntenticLineSchema)),
 };
 //# sourceMappingURL=intentic.contract.js.map

package/dist/contracts/intentic.contract.js.map

@@ -1 +1 @@
-{"version":3,"file":"intentic.contract.js","sourceRoot":"","sources":["../../src/contracts/intentic.contract.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAE,EAAE,EAAE,MAAM,gBAAgB,CAAC;AACnD,OAAO,EAAE,kBAAkB,EAAE,MAAM,cAAc,CAAC;AAClD,OAAO,EAAE,iBAAiB,EAAE,QAAQ,EAAE,MAAM,eAAe,CAAC;AAI5D,MAAM,CAAC,MAAM,gBAAgB,GAAG;IAC5B,GAAG,EAAE,EAAE,CAAC,KAAK,CAAC,EAAE,MAAM,EAAE,MAAM,EAAE,IAAI,EAAE,WAAW,EAAE,CAAC,CAAC,KAAK,CAAC,iBAAiB,CAAC,CAAC,MAAM,CAAC,aAAa,CAAC,kBAAkB,CAAC,CAAC;IAGvH,KAAK,EAAE,EAAE,CAAC,KAAK,CAAC,EAAE,MAAM,EAAE,MAAM,EAAE,IAAI,EAAE,iBAAiB,EAAE,CAAC,CAAC,MAAM,CAAC,QAAQ,CAAC;CAChF,CAAC"}
+{"version":3,"file":"intentic.contract.js","sourceRoot":"","sources":["../../src/contracts/intentic.contract.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAE,EAAE,EAAE,MAAM,gBAAgB,CAAC;AACnD,OAAO,EAAE,kBAAkB,EAAE,MAAM,cAAc,CAAC;AAClD,OAAO,EAAE,iBAAiB,EAAE,QAAQ,EAAE,MAAM,eAAe,CAAC;AAI5D,MAAM,CAAC,MAAM,gBAAgB,GAAG;IAC5B,GAAG,EAAE,EAAE,CAAC,KAAK,CAAC,EAAE,MAAM,EAAE,MAAM,EAAE,IAAI,EAAE,WAAW,EAAE,CAAC,CAAC,KAAK,CAAC,iBAAiB,CAAC,CAAC,MAAM,CAAC,aAAa,CAAC,kBAAkB,CAAC,CAAC;IAGvH,KAAK,EAAE,EAAE,CAAC,KAAK,CAAC,EAAE,MAAM,EAAE,MAAM,EAAE,IAAI,EAAE,iBAAiB,EAAE,CAAC,CAAC,MAAM,CAAC,QAAQ,CAAC;IAK7E,WAAW,EAAE,EAAE,CAAC,KAAK,CAAC,EAAE,MAAM,EAAE,KAAK,EAAE,IAAI,EAAE,wBAAwB,EAAE,CAAC,CAAC,MAAM,CAAC,aAAa,CAAC,kBAAkB,CAAC,CAAC;CACrH,CAAC"}

package/dist/contracts/inventory.contract.d.ts

@@ -3,10 +3,10 @@ export declare const inventoryContract: {
         entries: import("zod").ZodArray<import("zod").ZodDiscriminatedUnion<[import("zod").ZodObject<{
             kind: import("zod").ZodLiteral<"backend">;
             provider: import("zod").ZodEnum<{
-                host: "host";
                 cloudflare: "cloudflare";
                 github: "github";
                 gitlab: "gitlab";
+                host: "host";
                 stripe: "stripe";
             }>;
             name: import("zod").ZodString;
@@ -14,12 +14,12 @@ export declare const inventoryContract: {
         }, import("zod/v4/core").$strip>, import("zod").ZodObject<{
             kind: import("zod").ZodLiteral<"service">;
             service: import("zod").ZodEnum<{
-                signoz: "signoz";
+                infisical: "infisical";
+                invoiceninja: "invoiceninja";
+                openproject: "openproject";
                 outline: "outline";
                 paperless: "paperless";
-                openproject: "openproject";
-                invoiceninja: "invoiceninja";
-                infisical: "infisical";
+                signoz: "signoz";
             }>;
             name: import("zod").ZodString;
             values: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodUnion<readonly [import("zod").ZodString, import("zod").ZodNumber]>>;
@@ -36,10 +36,10 @@ export declare const inventoryContract: {
     add: import("@orpc/contract").ContractProcedureBuilderWithInputOutput<import("zod").ZodDiscriminatedUnion<[import("zod").ZodObject<{
         kind: import("zod").ZodLiteral<"backend">;
         provider: import("zod").ZodEnum<{
-            host: "host";
             cloudflare: "cloudflare";
             github: "github";
             gitlab: "gitlab";
+            host: "host";
             stripe: "stripe";
         }>;
         values: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodUnion<readonly [import("zod").ZodString, import("zod").ZodNumber]>>;
@@ -47,12 +47,12 @@ export declare const inventoryContract: {
     }, import("zod/v4/core").$strip>, import("zod").ZodObject<{
         kind: import("zod").ZodLiteral<"service">;
         service: import("zod").ZodEnum<{
-            signoz: "signoz";
+            infisical: "infisical";
+            invoiceninja: "invoiceninja";
+            openproject: "openproject";
             outline: "outline";
             paperless: "paperless";
-            openproject: "openproject";
-            invoiceninja: "invoiceninja";
-            infisical: "infisical";
+            signoz: "signoz";
         }>;
         values: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodUnion<readonly [import("zod").ZodString, import("zod").ZodNumber]>>;
         on: import("zod").ZodString;
@@ -68,10 +68,10 @@ export declare const inventoryContract: {
         entries: import("zod").ZodArray<import("zod").ZodDiscriminatedUnion<[import("zod").ZodObject<{
             kind: import("zod").ZodLiteral<"backend">;
             provider: import("zod").ZodEnum<{
-                host: "host";
                 cloudflare: "cloudflare";
                 github: "github";
                 gitlab: "gitlab";
+                host: "host";
                 stripe: "stripe";
             }>;
             name: import("zod").ZodString;
@@ -79,12 +79,12 @@ export declare const inventoryContract: {
         }, import("zod/v4/core").$strip>, import("zod").ZodObject<{
             kind: import("zod").ZodLiteral<"service">;
             service: import("zod").ZodEnum<{
-                signoz: "signoz";
+                infisical: "infisical";
+                invoiceninja: "invoiceninja";
+                openproject: "openproject";
                 outline: "outline";
                 paperless: "paperless";
-                openproject: "openproject";
-                invoiceninja: "invoiceninja";
-                infisical: "infisical";
+                signoz: "signoz";
             }>;
             name: import("zod").ZodString;
             values: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodUnion<readonly [import("zod").ZodString, import("zod").ZodNumber]>>;
@@ -104,10 +104,10 @@ export declare const inventoryContract: {
         entries: import("zod").ZodArray<import("zod").ZodDiscriminatedUnion<[import("zod").ZodObject<{
             kind: import("zod").ZodLiteral<"backend">;
             provider: import("zod").ZodEnum<{
-                host: "host";
                 cloudflare: "cloudflare";
                 github: "github";
                 gitlab: "gitlab";
+                host: "host";
                 stripe: "stripe";
             }>;
             name: import("zod").ZodString;
@@ -115,12 +115,12 @@ export declare const inventoryContract: {
         }, import("zod/v4/core").$strip>, import("zod").ZodObject<{
             kind: import("zod").ZodLiteral<"service">;
             service: import("zod").ZodEnum<{
-                signoz: "signoz";
+                infisical: "infisical";
+                invoiceninja: "invoiceninja";
+                openproject: "openproject";
                 outline: "outline";
                 paperless: "paperless";
-                openproject: "openproject";
-                invoiceninja: "invoiceninja";
-                infisical: "infisical";
+                signoz: "signoz";
             }>;
             name: import("zod").ZodString;
             values: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodUnion<readonly [import("zod").ZodString, import("zod").ZodNumber]>>;

package/dist/contracts/inventory.contract.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"inventory.contract.d.ts","sourceRoot":"","sources":["../../src/contracts/inventory.contract.ts"],"names":[],"mappings":"AAMA,eAAO,MAAM,iBAAiB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAI7B,CAAC"}
+{"version":3,"file":"inventory.contract.d.ts","sourceRoot":"","sources":["../../src/contracts/inventory.contract.ts"],"names":[],"mappings":"AAMA,eAAO,MAAM,iBAAiB;IAC1B,IAAI;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IACJ,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IACH,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CACT,CAAC"}

package/dist/contracts/logs.contract.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"logs.contract.d.ts","sourceRoot":"","sources":["../../src/contracts/logs.contract.ts"],"names":[],"mappings":"AAKA,eAAO,MAAM,YAAY;;;;;;;;;;;;;;;;;CAGxB,CAAC"}
+{"version":3,"file":"logs.contract.d.ts","sourceRoot":"","sources":["../../src/contracts/logs.contract.ts"],"names":[],"mappings":"AAKA,eAAO,MAAM,YAAY;IACrB,IAAI;;;;;;;IACJ,IAAI;;;;;;;;;CACP,CAAC"}

package/dist/contracts/panels.contract.d.ts

@@ -9,8 +9,8 @@ export declare const panelsContract: {
             previewUrl: import("zod").ZodOptional<import("zod").ZodString>;
             role: import("zod").ZodOptional<import("zod").ZodEnum<{
                 app: "app";
-                intent: "intent";
                 "desired-state": "desired-state";
+                intent: "intent";
             }>>;
             deployConfig: import("zod").ZodBoolean;
             desiredState: import("zod").ZodBoolean;

package/dist/contracts/panels.contract.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"panels.contract.d.ts","sourceRoot":"","sources":["../../src/contracts/panels.contract.ts"],"names":[],"mappings":"AAOA,eAAO,MAAM,cAAc;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAI1B,CAAC"}
+{"version":3,"file":"panels.contract.d.ts","sourceRoot":"","sources":["../../src/contracts/panels.contract.ts"],"names":[],"mappings":"AAOA,eAAO,MAAM,cAAc;IACvB,IAAI;;;;;;;;;;;;;;;;;;;;IACJ,KAAK;;;;;IACL,IAAI;;;;;CACP,CAAC"}

package/dist/contracts/ports.contract.d.ts

@@ -0,0 +1,31 @@
+export declare const portsContract: {
+    list: import("@orpc/contract").ContractProcedureBuilderWithOutput<import("@orpc/contract").Schema<unknown, unknown>, import("zod").ZodObject<{
+        ports: import("zod").ZodArray<import("zod").ZodObject<{
+            port: import("zod").ZodNumber;
+            host: import("zod").ZodEnum<{
+                "127.0.0.1": "127.0.0.1";
+                "::1": "::1";
+            }>;
+            kind: import("zod").ZodEnum<{
+                system: "system";
+                workspace: "workspace";
+            }>;
+            pid: import("zod").ZodOptional<import("zod").ZodNumber>;
+            command: import("zod").ZodOptional<import("zod").ZodString>;
+            cwd: import("zod").ZodOptional<import("zod").ZodString>;
+            forwarded: import("zod").ZodBoolean;
+            previewUrl: import("zod").ZodOptional<import("zod").ZodString>;
+        }, import("zod/v4/core").$strip>>;
+    }, import("zod/v4/core").$strip>, Record<never, never>, Record<never, never>>;
+    forward: import("@orpc/contract").ContractProcedureBuilderWithInputOutput<import("zod").ZodObject<{
+        port: import("zod").ZodNumber;
+    }, import("zod/v4/core").$strip>, import("zod").ZodObject<{
+        previewUrl: import("zod").ZodOptional<import("zod").ZodString>;
+    }, import("zod/v4/core").$strip>, Record<never, never>, Record<never, never>>;
+    unforward: import("@orpc/contract").ContractProcedureBuilderWithInputOutput<import("zod").ZodObject<{
+        port: import("zod").ZodNumber;
+    }, import("zod/v4/core").$strip>, import("zod").ZodObject<{
+        ok: import("zod").ZodLiteral<true>;
+    }, import("zod/v4/core").$strip>, Record<never, never>, Record<never, never>>;
+};
+//# sourceMappingURL=ports.contract.d.ts.map

package/dist/contracts/ports.contract.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ports.contract.d.ts","sourceRoot":"","sources":["../../src/contracts/ports.contract.ts"],"names":[],"mappings":"AAMA,eAAO,MAAM,aAAa;IACtB,IAAI;;;;;;;;;;;;;;;;;;IACJ,OAAO;;;;;IACP,SAAS;;;;;CACZ,CAAC"}

package/dist/contracts/ports.contract.js

@@ -0,0 +1,8 @@
+import { oc } from "@orpc/contract";
+import { OkSchema, PortForwardResultSchema, PortParamSchema, PortsListSchema } from "../schemas.js";
+export const portsContract = {
+    list: oc.route({ method: "GET", path: "/ports" }).output(PortsListSchema),
+    forward: oc.route({ method: "POST", path: "/ports/forward" }).input(PortParamSchema).output(PortForwardResultSchema),
+    unforward: oc.route({ method: "POST", path: "/ports/unforward" }).input(PortParamSchema).output(OkSchema),
+};
+//# sourceMappingURL=ports.contract.js.map

package/dist/contracts/ports.contract.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ports.contract.js","sourceRoot":"","sources":["../../src/contracts/ports.contract.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,EAAE,EAAE,MAAM,gBAAgB,CAAC;AACpC,OAAO,EAAE,QAAQ,EAAE,uBAAuB,EAAE,eAAe,EAAE,eAAe,EAAE,MAAM,eAAe,CAAC;AAKpG,MAAM,CAAC,MAAM,aAAa,GAAG;IACzB,IAAI,EAAE,EAAE,CAAC,KAAK,CAAC,EAAE,MAAM,EAAE,KAAK,EAAE,IAAI,EAAE,QAAQ,EAAE,CAAC,CAAC,MAAM,CAAC,eAAe,CAAC;IACzE,OAAO,EAAE,EAAE,CAAC,KAAK,CAAC,EAAE,MAAM,EAAE,MAAM,EAAE,IAAI,EAAE,gBAAgB,EAAE,CAAC,CAAC,KAAK,CAAC,eAAe,CAAC,CAAC,MAAM,CAAC,uBAAuB,CAAC;IACpH,SAAS,EAAE,EAAE,CAAC,KAAK,CAAC,EAAE,MAAM,EAAE,MAAM,EAAE,IAAI,EAAE,kBAAkB,EAAE,CAAC,CAAC,KAAK,CAAC,eAAe,CAAC,CAAC,MAAM,CAAC,QAAQ,CAAC;CAC5G,CAAC"}

package/dist/contracts/secrets.contract.d.ts

@@ -17,15 +17,16 @@ export declare const secretsContract: {
         entries: import("zod").ZodArray<import("zod").ZodObject<{
             key: import("zod").ZodString;
             kind: import("zod").ZodEnum<{
-                provider: "provider";
+                capability: "capability";
                 env: "env";
                 generated: "generated";
-                capability: "capability";
+                provider: "provider";
             }>;
+            label: import("zod").ZodOptional<import("zod").ZodString>;
             status: import("zod").ZodEnum<{
-                set: "set";
                 connected: "connected";
                 missing: "missing";
+                set: "set";
             }>;
             requiredBy: import("zod").ZodArray<import("zod").ZodObject<{
                 resourceId: import("zod").ZodString;

package/dist/contracts/secrets.contract.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"secrets.contract.d.ts","sourceRoot":"","sources":["../../src/contracts/secrets.contract.ts"],"names":[],"mappings":"AAQA,eAAO,MAAM,eAAe;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAM3B,CAAC"}
+{"version":3,"file":"secrets.contract.d.ts","sourceRoot":"","sources":["../../src/contracts/secrets.contract.ts"],"names":[],"mappings":"AAQA,eAAO,MAAM,eAAe;IACxB,GAAG;;;;;;IACH,IAAI;;;IACJ,MAAM;;;;;IACN,SAAS;;;;;;;;;;;;;;;;;;;;;;;;;;;IACT,MAAM;;;;;CACT,CAAC"}

package/dist/contracts/sessions.contract.d.ts

@@ -14,8 +14,8 @@ export declare const sessionsContract: {
     }, z.core.$strip>, z.ZodObject<{
         messages: z.ZodArray<z.ZodObject<{
             role: z.ZodEnum<{
-                user: "user";
                 assistant: "assistant";
+                user: "user";
             }>;
             text: z.ZodString;
         }, z.core.$strip>>;

package/dist/contracts/sessions.contract.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"sessions.contract.d.ts","sourceRoot":"","sources":["../../src/contracts/sessions.contract.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAMxB,eAAO,MAAM,gBAAgB;;;;;;;;;;;;;;;;;;;;;CAG5B,CAAC"}
+{"version":3,"file":"sessions.contract.d.ts","sourceRoot":"","sources":["../../src/contracts/sessions.contract.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAMxB,eAAO,MAAM,gBAAgB;IACzB,IAAI;;;;;;;;;IAIJ,GAAG;;;;;;;;;;;CACN,CAAC"}

package/dist/contracts/sessions.contract.js

@@ -2,7 +2,10 @@ import { oc } from "@orpc/contract";
 import { z } from "zod";
 import { SessionIdParamSchema, SessionsListSchema, SessionTranscriptSchema } from "../schemas.js";
 export const sessionsContract = {
-    list: oc.route({ method: "GET", path: "/sessions" }).input(z.object({ query: z.string().optional() })).output(SessionsListSchema),
+    list: oc
+        .route({ method: "GET", path: "/sessions" })
+        .input(z.object({ query: z.string().optional() }))
+        .output(SessionsListSchema),
     get: oc.route({ method: "GET", path: "/sessions/{id}" }).input(SessionIdParamSchema).output(SessionTranscriptSchema),
 };
 //# sourceMappingURL=sessions.contract.js.map

package/dist/contracts/sessions.contract.js.map

@@ -1 +1 @@
-{"version":3,"file":"sessions.contract.js","sourceRoot":"","sources":["../../src/contracts/sessions.contract.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,EAAE,EAAE,MAAM,gBAAgB,CAAC;AACpC,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AACxB,OAAO,EAAE,oBAAoB,EAAE,kBAAkB,EAAE,uBAAuB,EAAE,MAAM,eAAe,CAAC;AAKlG,MAAM,CAAC,MAAM,gBAAgB,GAAG;IAC5B,IAAI,EAAE,EAAE,CAAC,KAAK,CAAC,EAAE,MAAM,EAAE,KAAK,EAAE,IAAI,EAAE,WAAW,EAAE,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,MAAM,CAAC,EAAE,KAAK,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,QAAQ,EAAE,EAAE,CAAC,CAAC,CAAC,MAAM,CAAC,kBAAkB,CAAC;IACjI,GAAG,EAAE,EAAE,CAAC,KAAK,CAAC,EAAE,MAAM,EAAE,KAAK,EAAE,IAAI,EAAE,gBAAgB,EAAE,CAAC,CAAC,KAAK,CAAC,oBAAoB,CAAC,CAAC,MAAM,CAAC,uBAAuB,CAAC;CACvH,CAAC"}
+{"version":3,"file":"sessions.contract.js","sourceRoot":"","sources":["../../src/contracts/sessions.contract.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,EAAE,EAAE,MAAM,gBAAgB,CAAC;AACpC,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AACxB,OAAO,EAAE,oBAAoB,EAAE,kBAAkB,EAAE,uBAAuB,EAAE,MAAM,eAAe,CAAC;AAKlG,MAAM,CAAC,MAAM,gBAAgB,GAAG;IAC5B,IAAI,EAAE,EAAE;SACH,KAAK,CAAC,EAAE,MAAM,EAAE,KAAK,EAAE,IAAI,EAAE,WAAW,EAAE,CAAC;SAC3C,KAAK,CAAC,CAAC,CAAC,MAAM,CAAC,EAAE,KAAK,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,QAAQ,EAAE,EAAE,CAAC,CAAC;SACjD,MAAM,CAAC,kBAAkB,CAAC;IAC/B,GAAG,EAAE,EAAE,CAAC,KAAK,CAAC,EAAE,MAAM,EAAE,KAAK,EAAE,IAAI,EAAE,gBAAgB,EAAE,CAAC,CAAC,KAAK,CAAC,oBAAoB,CAAC,CAAC,MAAM,CAAC,uBAAuB,CAAC;CACvH,CAAC"}

package/dist/contracts/settings.contract.d.ts

@@ -1,11 +1,50 @@
 export declare const settingsContract: {
     get: import("@orpc/contract").ContractProcedureBuilderWithOutput<import("@orpc/contract").Schema<unknown, unknown>, import("zod").ZodObject<{
-        searchPastChats: import("zod").ZodBoolean;
+        stableSystemPrompt: import("zod").ZodBoolean;
+        skills: import("zod").ZodArray<import("zod").ZodString>;
+        hashlineEdits: import("zod").ZodBoolean;
+        terseOutput: import("zod").ZodBoolean;
+        iqSearch: import("zod").ZodBoolean;
+        outputCleaners: import("zod").ZodString;
+        outputHoldout: import("zod").ZodNumber;
+        filterBackend: import("zod").ZodEnum<{
+            native: "native";
+            rtk: "rtk";
+        }>;
     }, import("zod/v4/core").$strip>, Record<never, never>, Record<never, never>>;
     set: import("@orpc/contract").ContractProcedureBuilderWithInputOutput<import("zod").ZodObject<{
-        searchPastChats: import("zod").ZodBoolean;
+        stableSystemPrompt: import("zod").ZodBoolean;
+        skills: import("zod").ZodArray<import("zod").ZodString>;
+        hashlineEdits: import("zod").ZodBoolean;
+        terseOutput: import("zod").ZodBoolean;
+        iqSearch: import("zod").ZodBoolean;
+        outputCleaners: import("zod").ZodString;
+        outputHoldout: import("zod").ZodNumber;
+        filterBackend: import("zod").ZodEnum<{
+            native: "native";
+            rtk: "rtk";
+        }>;
     }, import("zod/v4/core").$strip>, import("zod").ZodObject<{
         ok: import("zod").ZodLiteral<true>;
     }, import("zod/v4/core").$strip>, Record<never, never>, Record<never, never>>;
+    savings: import("@orpc/contract").ContractProcedureBuilderWithOutput<import("@orpc/contract").Schema<unknown, unknown>, import("zod").ZodObject<{
+        commands: import("zod").ZodNumber;
+        rawTokens: import("zod").ZodNumber;
+        emittedTokens: import("zod").ZodNumber;
+        savedPct: import("zod").ZodNumber;
+        perCleaner: import("zod").ZodArray<import("zod").ZodObject<{
+            id: import("zod").ZodString;
+            commands: import("zod").ZodNumber;
+        }, import("zod/v4/core").$strip>>;
+        holdout: import("zod").ZodObject<{
+            cleaned: import("zod").ZodNumber;
+            heldOut: import("zod").ZodNumber;
+            measuredSavedPct: import("zod").ZodOptional<import("zod").ZodNumber>;
+        }, import("zod/v4/core").$strip>;
+        gaps: import("zod").ZodArray<import("zod").ZodObject<{
+            command: import("zod").ZodString;
+            tokens: import("zod").ZodNumber;
+        }, import("zod/v4/core").$strip>>;
+    }, import("zod/v4/core").$strip>, Record<never, never>, Record<never, never>>;
 };
 //# sourceMappingURL=settings.contract.d.ts.map

package/dist/contracts/settings.contract.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"settings.contract.d.ts","sourceRoot":"","sources":["../../src/contracts/settings.contract.ts"],"names":[],"mappings":"AAKA,eAAO,MAAM,gBAAgB;;;;;;;;;CAG5B,CAAC"}
+{"version":3,"file":"settings.contract.d.ts","sourceRoot":"","sources":["../../src/contracts/settings.contract.ts"],"names":[],"mappings":"AAMA,eAAO,MAAM,gBAAgB;IACzB,GAAG;;;;;;;;;;;;;IACH,GAAG;;;;;;;;;;;;;;;IACH,OAAO;;;;;;;;;;;;;;;;;;;CACV,CAAC"}

package/dist/contracts/settings.contract.js

@@ -1,7 +1,8 @@
 import { oc } from "@orpc/contract";
-import { OkSchema, SandboxSettingsSchema } from "../schemas.js";
+import { CleanerSavingsSchema, OkSchema, SandboxSettingsSchema } from "../schemas.js";
 export const settingsContract = {
     get: oc.route({ method: "GET", path: "/settings" }).output(SandboxSettingsSchema),
     set: oc.route({ method: "POST", path: "/settings" }).input(SandboxSettingsSchema).output(OkSchema),
+    savings: oc.route({ method: "GET", path: "/settings/savings" }).output(CleanerSavingsSchema),
 };
 //# sourceMappingURL=settings.contract.js.map

package/dist/contracts/settings.contract.js.map

@@ -1 +1 @@
-{"version":3,"file":"settings.contract.js","sourceRoot":"","sources":["../../src/contracts/settings.contract.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,EAAE,EAAE,MAAM,gBAAgB,CAAC;AACpC,OAAO,EAAE,QAAQ,EAAE,qBAAqB,EAAE,MAAM,eAAe,CAAC;AAIhE,MAAM,CAAC,MAAM,gBAAgB,GAAG;IAC5B,GAAG,EAAE,EAAE,CAAC,KAAK,CAAC,EAAE,MAAM,EAAE,KAAK,EAAE,IAAI,EAAE,WAAW,EAAE,CAAC,CAAC,MAAM,CAAC,qBAAqB,CAAC;IACjF,GAAG,EAAE,EAAE,CAAC,KAAK,CAAC,EAAE,MAAM,EAAE,MAAM,EAAE,IAAI,EAAE,WAAW,EAAE,CAAC,CAAC,KAAK,CAAC,qBAAqB,CAAC,CAAC,MAAM,CAAC,QAAQ,CAAC;CACrG,CAAC"}
+{"version":3,"file":"settings.contract.js","sourceRoot":"","sources":["../../src/contracts/settings.contract.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,EAAE,EAAE,MAAM,gBAAgB,CAAC;AACpC,OAAO,EAAE,oBAAoB,EAAE,QAAQ,EAAE,qBAAqB,EAAE,MAAM,eAAe,CAAC;AAKtF,MAAM,CAAC,MAAM,gBAAgB,GAAG;IAC5B,GAAG,EAAE,EAAE,CAAC,KAAK,CAAC,EAAE,MAAM,EAAE,KAAK,EAAE,IAAI,EAAE,WAAW,EAAE,CAAC,CAAC,MAAM,CAAC,qBAAqB,CAAC;IACjF,GAAG,EAAE,EAAE,CAAC,KAAK,CAAC,EAAE,MAAM,EAAE,MAAM,EAAE,IAAI,EAAE,WAAW,EAAE,CAAC,CAAC,KAAK,CAAC,qBAAqB,CAAC,CAAC,MAAM,CAAC,QAAQ,CAAC;IAClG,OAAO,EAAE,EAAE,CAAC,KAAK,CAAC,EAAE,MAAM,EAAE,KAAK,EAAE,IAAI,EAAE,mBAAmB,EAAE,CAAC,CAAC,MAAM,CAAC,oBAAoB,CAAC;CAC/F,CAAC"}

package/dist/contracts/system.contract.d.ts

@@ -4,6 +4,8 @@ export declare const systemContract: {
         name: z.ZodOptional<z.ZodString>;
         image: z.ZodOptional<z.ZodString>;
         version: z.ZodOptional<z.ZodString>;
+        latest: z.ZodOptional<z.ZodString>;
+        updateAvailable: z.ZodOptional<z.ZodBoolean>;
     }, z.core.$strip>, Record<never, never>, Record<never, never>>;
     events: import("@orpc/contract").ContractProcedureBuilderWithInputOutput<z.ZodObject<{
         clientId: z.ZodOptional<z.ZodString>;
@@ -15,38 +17,120 @@ export declare const systemContract: {
     } | {
         kind: "workspaceChanged";
         paths: string[];
+    } | {
+        kind: "reposChanged";
+        repos: string[];
     } | {
         kind: "presence";
         users: {
             clientId: string;
             email: string;
-            idle: boolean;
             name?: string | undefined;
             picture?: string | undefined;
+            idle: boolean;
             view?: string | undefined;
             sessionId?: string | undefined;
             path?: string | undefined;
         }[];
-    }, unknown, void>, import("@orpc/contract").AsyncIteratorClass<{
-        kind: "heartbeat";
     } | {
+        kind: "agents";
+        agents: {
+            id: string;
+            sessionId?: string | undefined;
+            title?: string | undefined;
+            status: "awaiting" | "conflict" | "error" | "idle" | "landed" | "running";
+            provider: string;
+            harness: "claude-code" | "native";
+            model?: string | undefined;
+            account?: string | undefined;
+            branch?: string | undefined;
+            base?: string | undefined;
+            costUsd?: number | undefined;
+            inputTokens?: number | undefined;
+            outputTokens?: number | undefined;
+            contextTokens?: number | undefined;
+            contextWindow?: number | undefined;
+            activity?: {
+                tool?: string | undefined;
+                target?: string | undefined;
+                todo?: string | undefined;
+            } | undefined;
+            startedAt?: number | undefined;
+            updatedAt: number;
+            attention: {
+                plan: boolean;
+                question: boolean;
+                conflict: boolean;
+            };
+            turns?: number | undefined;
+            toolUses?: number | undefined;
+            diff?: {
+                files: number;
+                insertions: number;
+                deletions: number;
+            } | undefined;
+        }[];
+    }, unknown, void>, import("@orpc/contract").AsyncIteratorClass<{
         kind: "hello";
         workspaceId: string;
+    } | {
+        kind: "heartbeat";
     } | {
         kind: "workspaceChanged";
         paths: string[];
+    } | {
+        kind: "reposChanged";
+        repos: string[];
     } | {
         kind: "presence";
         users: {
             clientId: string;
             email: string;
-            idle: boolean;
             name?: string | undefined;
             picture?: string | undefined;
+            idle: boolean;
             view?: string | undefined;
             sessionId?: string | undefined;
             path?: string | undefined;
         }[];
+    } | {
+        kind: "agents";
+        agents: {
+            id: string;
+            sessionId?: string | undefined;
+            title?: string | undefined;
+            status: "awaiting" | "conflict" | "error" | "idle" | "landed" | "running";
+            provider: string;
+            harness: "claude-code" | "native";
+            model?: string | undefined;
+            account?: string | undefined;
+            branch?: string | undefined;
+            base?: string | undefined;
+            costUsd?: number | undefined;
+            inputTokens?: number | undefined;
+            outputTokens?: number | undefined;
+            contextTokens?: number | undefined;
+            contextWindow?: number | undefined;
+            activity?: {
+                tool?: string | undefined;
+                target?: string | undefined;
+                todo?: string | undefined;
+            } | undefined;
+            startedAt?: number | undefined;
+            updatedAt: number;
+            attention: {
+                plan: boolean;
+                question: boolean;
+                conflict: boolean;
+            };
+            turns?: number | undefined;
+            toolUses?: number | undefined;
+            diff?: {
+                files: number;
+                insertions: number;
+                deletions: number;
+            } | undefined;
+        }[];
     }, unknown, void>>, Record<never, never>, Record<never, never>>;
     presence: import("@orpc/contract").ContractProcedureBuilderWithInputOutput<z.ZodObject<{
         clientId: z.ZodString;
@@ -63,16 +147,32 @@ export declare const systemContract: {
         hostname: z.ZodString;
         tunnelToken: z.ZodString;
     }, z.core.$strip>, Record<never, never>, Record<never, never>>;
+    usage: import("@orpc/contract").ContractProcedureBuilderWithOutput<import("@orpc/contract").Schema<unknown, unknown>, z.ZodObject<{
+        accounts: z.ZodArray<z.ZodObject<{
+            provider: z.ZodString;
+            account: z.ZodString;
+            turns: z.ZodNumber;
+            inputTokens: z.ZodNumber;
+            outputTokens: z.ZodNumber;
+            cacheReadTokens: z.ZodNumber;
+            cacheCreationTokens: z.ZodNumber;
+            costUsd: z.ZodNumber;
+        }, z.core.$strip>>;
+    }, z.core.$strip>, Record<never, never>, Record<never, never>>;
     terminals: import("@orpc/contract").ContractProcedureBuilderWithOutput<import("@orpc/contract").Schema<unknown, unknown>, z.ZodObject<{
         sessions: z.ZodArray<z.ZodObject<{
             name: z.ZodString;
             label: z.ZodOptional<z.ZodString>;
             kind: z.ZodEnum<{
                 agent: "agent";
-                shell: "shell";
+                job: "job";
                 panel: "panel";
+                process: "process";
+                shell: "shell";
             }>;
             running: z.ZodBoolean;
+            extensionId: z.ZodOptional<z.ZodString>;
+            processName: z.ZodOptional<z.ZodString>;
         }, z.core.$strip>>;
     }, z.core.$strip>, Record<never, never>, Record<never, never>>;
     killTerminal: import("@orpc/contract").ContractProcedureBuilderWithInputOutput<z.ZodObject<{

package/dist/contracts/system.contract.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"system.contract.d.ts","sourceRoot":"","sources":["../../src/contracts/system.contract.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAiBxB,eAAO,MAAM,cAAc;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAe1B,CAAC"}
+{"version":3,"file":"system.contract.d.ts","sourceRoot":"","sources":["../../src/contracts/system.contract.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAkBxB,eAAO,MAAM,cAAc;IACvB,IAAI;;;;;;;IACJ,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IAKN,QAAQ;;;;;;;;;IACR,UAAU;;;;;;IAEV,KAAK;;;;;;;;;;;;IAKL,SAAS;;;;;;;;;;;;;;;;IACT,YAAY;;;;;CACf,CAAC"}