runwork 0.10.1 → 0.10.3

package/dist/commands/__tests__/clone-args.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/commands/__tests__/clone-args.test.js

@@ -0,0 +1,44 @@
+import { describe, it, expect } from 'vitest';
+import { normalizeCloneArgs } from '../clone.js';
+describe('normalizeCloneArgs', () => {
+    it('passes through both args unchanged when --app is not provided', () => {
+        expect(normalizeCloneArgs('app-id', 'C:/dir', undefined)).toEqual({
+            appId: 'app-id',
+            directory: 'C:/dir',
+        });
+        expect(normalizeCloneArgs('app-id', 'C:/dir', {})).toEqual({
+            appId: 'app-id',
+            directory: 'C:/dir',
+        });
+    });
+    it('passes through both args unchanged when --app is set but directory is also explicit', () => {
+        expect(normalizeCloneArgs('app-id', 'C:/dir', { app: 'foo' })).toEqual({ appId: 'app-id', directory: 'C:/dir' });
+    });
+    it('shifts the first positional to directory when --app is set and only one positional arg is present', () => {
+        // The reproducer from the field:
+        //   runwork clone --app academic-grade-conversion C:\Users\Oytun\Desktop\agc-test
+        // commander binds rawAppId = "C:\Users\..." and rawDirectory = undefined.
+        expect(normalizeCloneArgs('C:\\Users\\Oytun\\Desktop\\agc-test', undefined, {
+            app: 'academic-grade-conversion',
+        })).toEqual({
+            appId: undefined,
+            directory: 'C:\\Users\\Oytun\\Desktop\\agc-test',
+        });
+    });
+    it('does not shift when --app is set and no positional args are provided', () => {
+        expect(normalizeCloneArgs(undefined, undefined, { app: 'foo' })).toEqual({
+            appId: undefined,
+            directory: undefined,
+        });
+    });
+    it('does not shift when --app is set with only the directory positional (rawAppId already undefined)', () => {
+        // commander binds positional arguments left-to-right; if only one is
+        // given, it's always rawAppId. So this case shouldn't arise in practice
+        // -- but if a future commander upgrade changes that, we should leave
+        // already-correct args alone.
+        expect(normalizeCloneArgs(undefined, 'C:/dir', { app: 'foo' })).toEqual({
+            appId: undefined,
+            directory: 'C:/dir',
+        });
+    });
+});

package/dist/commands/clone.d.ts

@@ -10,4 +10,18 @@ export interface CloneResult {
     workspaceName: string;
 }
 export declare function execClone(client: ApiClient, app: AppInfo, directory?: string, creds?: Credentials | null): Promise<CloneResult>;
+/**
+ * Reconcile positional args with --app. When --app is provided, the first
+ * positional argument is intended as the *directory* -- not another appId
+ * -- because the app is already disambiguated by the option. Without this,
+ * `runwork clone --app foo C:\path\to\dir` ends up parsing `C:\path\to\dir`
+ * as `appId` (which is then ignored because `--app` wins), leaving
+ * `directory` undefined and silently cloning into the slug under cwd.
+ */
+export declare function normalizeCloneArgs(appId: string | undefined, directory: string | undefined, options: {
+    app?: string;
+} | undefined): {
+    appId: string | undefined;
+    directory: string | undefined;
+};
 export declare const cloneCommand: Command;

package/dist/commands/clone.js

@@ -109,13 +109,28 @@ export async function execClone(client, app, directory, creds) {
         workspaceName: app.workspaceName,
     };
 }
+/**
+ * Reconcile positional args with --app. When --app is provided, the first
+ * positional argument is intended as the *directory* -- not another appId
+ * -- because the app is already disambiguated by the option. Without this,
+ * `runwork clone --app foo C:\path\to\dir` ends up parsing `C:\path\to\dir`
+ * as `appId` (which is then ignored because `--app` wins), leaving
+ * `directory` undefined and silently cloning into the slug under cwd.
+ */
+export function normalizeCloneArgs(appId, directory, options) {
+    if (options?.app && appId && !directory) {
+        return { appId: undefined, directory: appId };
+    }
+    return { appId, directory };
+}
 export const cloneCommand = new Command('clone')
     .description('Clone a Runwork app to local development')
     .argument('[appId]', 'App ID to clone (interactive if omitted)')
     .argument('[directory]', 'Target directory')
     .option('--app <name-or-id>', 'App name or ID (skips interactive selection)')
-    .action(async (appId, directory, options) => {
+    .action(async (rawAppId, rawDirectory, options) => {
     requireGit('clone');
+    const { appId, directory } = normalizeCloneArgs(rawAppId, rawDirectory, options);
     const creds = requireAuth();
     const client = new ApiClient(creds);
     const useJson = shouldOutputJson(undefined);
@@ -151,7 +166,10 @@ export const cloneCommand = new Command('clone')
         jsonOut(response);
         return;
     }
-    console.log(`\nApp "${cloneResult.appName}" cloned to ${cloneResult.directory}/`);
+    // No trailing separator: cloneResult.directory is already an absolute
+    // path. Appending '/' here mixed with Windows '\' separators produced
+    // confusing output like `C:\Users\...\app/` on Windows.
+    console.log(`\nApp "${cloneResult.appName}" cloned to ${cloneResult.directory}`);
     console.log(`Remote: ${client.getGitRemoteUrl(cloneResult.workspaceId, cloneResult.appId)}`);
     await runAgentWizard(cloneResult.directory);
     console.log(`Next: cd ${cloneResult.slug} && runwork dev`);

package/dist/commands/dev.d.ts

@@ -1,7 +1,10 @@
 import { Command } from 'commander';
+import { type SessionMode } from '../dev/session.js';
 export declare function execDev(options?: {
     logs?: boolean;
     logsOnlyFile?: boolean;
     json?: boolean;
+    mode?: SessionMode;
+    restart?: boolean;
 }): Promise<void>;
 export declare const devCommand: Command;