@quo-systems/dock 0.1.0

package/dist/cli/client.js

@@ -0,0 +1,51 @@
+// SPDX-License-Identifier: Apache-2.0
+// A client of the daemon's socket. One ask, one line, one reply. This is
+// what every subcommand but init and serve is: connect, ask, print, exit.
+import { connect } from 'node:net';
+import { createInterface } from 'node:readline';
+import { sockPath, sidePath } from './daemon.js';
+// `via` names a standing the ward's user being holds at another ward: the
+// ask is then an owner's ask at that ward's door, sealed, and the answer is
+// the far ward's. Without it the ask is the root's, on the pointer.
+export function ask(dir, method, args = {}, ward = 'main', via) {
+    return line(dir, via === undefined ? { ward, method, args } : { ward, method, args, via });
+}
+// `quo reach`: a hint for the harbor's directory, which is the harbor's and
+// not a ward's, so it crosses the root socket as its own line.
+export function reach(dir, pk, url) {
+    return line(dir, { reach: { pk, url } });
+}
+function line(dir, body) {
+    return new Promise((ok, no) => {
+        const c = connect(sockPath(dir));
+        const id = Math.random().toString(36).slice(2);
+        c.once('error', (e) => no(e.code === 'ENOENT' || e.code === 'ECONNREFUSED' ? new Error(`no daemon at ${dir}: run \`quo serve\``) : e));
+        c.once('connect', () => {
+            c.write(JSON.stringify({ id, ...body }) + '\n');
+            createInterface({ input: c }).once('line', (line) => {
+                c.end();
+                const r = JSON.parse(line);
+                ok(r.error !== undefined ? { error: r.error } : { result: r.result });
+            });
+        });
+    });
+}
+export function side(dir, as, ward = 'main', run) {
+    return new Promise((ok, no) => {
+        const c = connect(sidePath(dir));
+        c.once('error', (e) => no(e.code === 'ENOENT' || e.code === 'ECONNREFUSED' ? new Error(`no daemon at ${dir}: run \`quo serve\``) : e));
+        c.once('connect', () => {
+            c.write(JSON.stringify(run ? { as, ward, run } : { as, ward }) + '\n');
+            const lines = createInterface({ input: c });
+            lines.once('line', (hello) => {
+                const h = JSON.parse(hello);
+                if (h.error !== undefined)
+                    return no(new Error(h.error));
+                lines.on('line', (line) => process.stdout.write(line + '\n'));
+                createInterface({ input: process.stdin }).on('line', (line) => c.write(line + '\n'));
+                process.stdin.once('end', () => c.end());
+            });
+            c.once('close', () => ok());
+        });
+    });
+}

package/dist/cli/daemon.d.ts

@@ -0,0 +1,57 @@
+import { type IncomingMessage, type ServerResponse } from 'node:http';
+import { Socket as Held, type Dialer } from '@quo-systems/quo/harbor';
+import { DiskHarbor, type Hosted } from '../harbor/disk.ts';
+import { type Avatar } from '../beings/index.ts';
+import { type Agent } from '../mcp/agent.ts';
+import { OAuth } from '../mcp/oauth.ts';
+import { Exchange } from '../mcp/web/exchange.ts';
+import { McpHttp } from '../mcp/http.ts';
+export type Handler = (req: IncomingMessage, res: ServerResponse, rest: string) => void | Promise<void>;
+export type Http = {
+    port: number;
+    host: string;
+    mount(prefix: string, handler: Handler): void;
+};
+export type Quo = {
+    sockets: Set<Held>;
+    dialers: Dialer[];
+};
+export type Serving = {
+    harbor: DiskHarbor;
+    sock: string;
+    side: string;
+    http: Http | null;
+    oauth: OAuth | null;
+    exchange: Exchange | null;
+    mcp: McpHttp | null;
+    agents: Map<string, Agent>;
+    quo: Quo;
+    close(): Promise<void>;
+};
+export type Routes = {
+    mcp: string;
+    web: string;
+    quo?: string;
+};
+export type Agents = Record<string, {
+    command: string;
+    args?: string[];
+    dir: string;
+}>;
+export type Options = {
+    http?: {
+        port: number;
+        host?: string;
+    };
+    routes?: Routes;
+    agents?: Agents;
+    dial?: string[];
+    password?: () => string | undefined;
+};
+export declare const sockPath: (dir: string) => string;
+export declare const sidePath: (dir: string) => string;
+export declare function admit(hosted: Hosted, identity: string, kind: 'local' | 'web', wake?: boolean): Promise<{
+    avatar?: Avatar;
+    error?: string;
+}>;
+export declare function serve(dir: string, options?: Options): Promise<Serving>;